diff --git a/toolchain/check/call.cpp b/toolchain/check/call.cpp index 27010a6a69de..b1d065284152 100644 --- a/toolchain/check/call.cpp +++ b/toolchain/check/call.cpp @@ -179,7 +179,7 @@ auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id, builder.Note(function.return_slot_pattern_id, IncompleteReturnTypeHere); }); - return CheckFunctionReturnType(context, callee_id, function, + return CheckFunctionReturnType(context, loc_id, function, *callee_specific_id); }(); switch (return_info.init_repr.kind) { diff --git a/toolchain/check/context.cpp b/toolchain/check/context.cpp index 0f22b08c0da9..f7f9c9791bcc 100644 --- a/toolchain/check/context.cpp +++ b/toolchain/check/context.cpp @@ -498,7 +498,7 @@ struct ProhibitedAccessInfo { }; auto Context::AppendLookupScopesForConstant( - SemIRLoc loc, SemIR::ConstantId base_const_id, + SemIR::LocId loc_id, SemIR::ConstantId base_const_id, llvm::SmallVector* scopes) -> bool { auto base_id = constant_values().GetInstId(base_const_id); auto base = insts().Get(base_id); @@ -509,11 +509,12 @@ auto Context::AppendLookupScopesForConstant( return true; } if (auto base_as_class = base.TryAs()) { - TryToDefineType(GetTypeIdForTypeConstant(base_const_id), [&] { + TryToDefineType(GetTypeIdForTypeConstant(base_const_id), loc_id, [&] { CARBON_DIAGNOSTIC(QualifiedExprInIncompleteClassScope, Error, "member access into incomplete class {0}", InstIdAsType); - return emitter().Build(loc, QualifiedExprInIncompleteClassScope, base_id); + return emitter().Build(loc_id, QualifiedExprInIncompleteClassScope, + base_id); }); auto& class_info = classes().Get(base_as_class->class_id); scopes->push_back(LookupScope{.name_scope_id = class_info.scope_id, @@ -521,11 +522,11 @@ auto Context::AppendLookupScopesForConstant( return true; } if (auto base_as_facet_type = base.TryAs()) { - TryToDefineType(GetTypeIdForTypeConstant(base_const_id), [&] { + TryToDefineType(GetTypeIdForTypeConstant(base_const_id), loc_id, [&] { CARBON_DIAGNOSTIC(QualifiedExprInUndefinedInterfaceScope, Error, "member access into undefined interface {0}", InstIdAsType); - return emitter().Build(loc, QualifiedExprInUndefinedInterfaceScope, + return emitter().Build(loc_id, QualifiedExprInUndefinedInterfaceScope, base_id); }); const auto& facet_type_info = @@ -550,7 +551,7 @@ auto Context::AppendLookupScopesForConstant( return false; } -auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, +auto Context::LookupQualifiedName(SemIR::LocId loc_id, SemIR::NameId name_id, llvm::ArrayRef lookup_scopes, bool required, std::optional access_info) @@ -576,7 +577,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, has_error |= name_scope.has_error(); auto [scope_result_id, access_kind] = - LookupNameInExactScope(loc, name_id, scope_id, name_scope); + LookupNameInExactScope(loc_id, name_id, scope_id, name_scope); auto is_access_prohibited = IsAccessProhibited(access_info, access_kind, is_parent_access); @@ -610,7 +611,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, "declared as an extended scope here"); builder.Note(extended_id, FromExtendHere); }); - if (!AppendLookupScopesForConstant(loc, const_id, &scopes)) { + if (!AppendLookupScopesForConstant(loc_id, const_id, &scopes)) { // TODO: Handle case where we have a symbolic type and instead should // look in its type. } @@ -625,7 +626,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, NameAmbiguousDueToExtend, Error, "ambiguous use of name `{0}` found in multiple extended scopes", SemIR::NameId); - emitter_->Emit(loc, NameAmbiguousDueToExtend, name_id); + emitter_->Emit(loc_id, NameAmbiguousDueToExtend, name_id); // TODO: Add notes pointing to the scopes. return {.specific_id = SemIR::SpecificId::Invalid, .inst_id = SemIR::ErrorInst::SingletonInstId}; @@ -638,7 +639,7 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, if (required && !result.inst_id.is_valid()) { if (!has_error) { if (prohibited_accesses.empty()) { - DiagnoseMemberNameNotFound(loc, name_id, lookup_scopes); + DiagnoseMemberNameNotFound(loc_id, name_id, lookup_scopes); } else { // TODO: We should report multiple prohibited accesses in case we don't // find a valid lookup. Reporting the last one should suffice for now. @@ -647,9 +648,9 @@ auto Context::LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, // Note, `access_info` is guaranteed to have a value here, since // `prohibited_accesses` is non-empty. - DiagnoseInvalidQualifiedNameAccess(*this, loc, scope_result_id, name_id, - access_kind, is_parent_access, - *access_info); + DiagnoseInvalidQualifiedNameAccess(*this, loc_id, scope_result_id, + name_id, access_kind, + is_parent_access, *access_info); } } @@ -1278,13 +1279,24 @@ class TypeCompleter { }; } // namespace -auto Context::TryToCompleteType(SemIR::TypeId type_id, +auto Context::TryToCompleteType(SemIR::TypeId type_id, SemIR::LocId loc_id, BuildDiagnosticFn diagnoser, BuildDiagnosticFn abstract_diagnoser) -> bool { if (!TypeCompleter(*this, diagnoser).Complete(type_id)) { return false; } + // For a symbolic type, create an instruction to require the corresponding + // specific type to be complete. + if (diagnoser && type_id.AsConstantId().is_symbolic()) { + // TODO: Deduplicate these. + AddInstInNoBlock(SemIR::LocIdAndInst( + loc_id, + SemIR::RequireCompleteType{ + .type_id = GetSingletonType(SemIR::WitnessType::SingletonInstId), + .complete_type_id = type_id})); + } + if (!abstract_diagnoser) { return true; } @@ -1308,9 +1320,9 @@ auto Context::TryToCompleteType(SemIR::TypeId type_id, return true; } -auto Context::TryToDefineType(SemIR::TypeId type_id, +auto Context::TryToDefineType(SemIR::TypeId type_id, SemIR::LocId loc_id, BuildDiagnosticFn diagnoser) -> bool { - if (!TryToCompleteType(type_id, diagnoser)) { + if (!TryToCompleteType(type_id, loc_id, diagnoser)) { return false; } diff --git a/toolchain/check/context.h b/toolchain/check/context.h index 436586c6def1..42c76b1f15af 100644 --- a/toolchain/check/context.h +++ b/toolchain/check/context.h @@ -225,14 +225,14 @@ class Context { // Appends the lookup scopes corresponding to `base_const_id` to `*scopes`. // Returns `false` if not a scope. On invalid scopes, prints a diagnostic, but // still updates `*scopes` and returns `true`. - auto AppendLookupScopesForConstant(SemIRLoc loc, + auto AppendLookupScopesForConstant(SemIR::LocId loc_id, SemIR::ConstantId base_const_id, llvm::SmallVector* scopes) -> bool; // Performs a qualified name lookup in a specified scopes and in scopes that // they extend, returning the referenced instruction. - auto LookupQualifiedName(SemIRLoc loc, SemIR::NameId name_id, + auto LookupQualifiedName(SemIR::LocId loc_id, SemIR::NameId name_id, llvm::ArrayRef lookup_scopes, bool required = true, std::optional access_info = std::nullopt) @@ -344,10 +344,21 @@ class Context { // If the type is not complete, `diagnoser` is invoked to diagnose the issue, // if a `diagnoser` is provided. The builder it returns will be annotated to // describe the reason why the type is not complete. - auto TryToCompleteType(SemIR::TypeId type_id, - BuildDiagnosticFn diagnoser = nullptr, + // + // If `diagnoser` is provided, it is assumed to be an error for the type to be + // incomplete, and `diagnoser` should build an error diagnostic. If `type_id` + // is dependent, the completeness of the type will be enforced during + // monomorphization, and `loc_id` is used as the location for a diagnostic + // produced at that time. + // + // Returns `true` if the type is symbolic. + auto TryToCompleteType(SemIR::TypeId type_id, SemIR::LocId loc_id, + BuildDiagnosticFn diagnoser, BuildDiagnosticFn abstract_diagnoser = nullptr) -> bool; + auto TryToCompleteType(SemIR::TypeId type_id) -> bool { + return TryToCompleteType(type_id, SemIR::LocId::Invalid, nullptr); + } // Attempts to complete and define the type `type_id`. Returns `true` if the // type is defined, or `false` if no definition is available. A defined type @@ -355,16 +366,17 @@ class Context { // // This is the same as `TryToCompleteType` except for interfaces, which are // complete before they are fully defined. - auto TryToDefineType(SemIR::TypeId type_id, + auto TryToDefineType(SemIR::TypeId type_id, SemIR::LocId loc_id, BuildDiagnosticFn diagnoser = nullptr) -> bool; // Returns the type `type_id` as a complete type, or produces an incomplete // type error and returns an error type. This is a convenience wrapper around // TryToCompleteType. `diagnoser` must not be null. - auto AsCompleteType(SemIR::TypeId type_id, BuildDiagnosticFn diagnoser, + auto AsCompleteType(SemIR::TypeId type_id, SemIR::LocId loc_id, + BuildDiagnosticFn diagnoser, BuildDiagnosticFn abstract_diagnoser = nullptr) -> SemIR::TypeId { - return TryToCompleteType(type_id, diagnoser, abstract_diagnoser) + return TryToCompleteType(type_id, loc_id, diagnoser, abstract_diagnoser) ? type_id : SemIR::ErrorInst::SingletonTypeId; } diff --git a/toolchain/check/convert.cpp b/toolchain/check/convert.cpp index 4ee4feac5468..2658ca16bb5b 100644 --- a/toolchain/check/convert.cpp +++ b/toolchain/check/convert.cpp @@ -968,7 +968,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id, // We can only perform initialization for complete types. if (!context.TryToCompleteType( - target.type_id, + target.type_id, loc_id, [&] { CARBON_CHECK(!target.is_initializer(), "Initialization of incomplete types is expected to be " diff --git a/toolchain/check/eval.cpp b/toolchain/check/eval.cpp index 62be16f00ba0..e195dca3d27b 100644 --- a/toolchain/check/eval.cpp +++ b/toolchain/check/eval.cpp @@ -1768,6 +1768,47 @@ static auto TryEvalInstInContext(EvalContext& eval_context, return MakeConstantResult(eval_context.context(), typed_inst, phase); } + case CARBON_KIND(SemIR::RequireCompleteType require_complete): { + auto phase = Phase::Template; + auto witness_type_id = eval_context.context().GetSingletonType( + SemIR::WitnessType::SingletonInstId); + auto complete_type_id = GetConstantValue( + eval_context, require_complete.complete_type_id, &phase); + + // If the type is a template constant, require it to be complete now. + if (phase == Phase::Template) { + // No location is needed here because we know the type is not a symbolic + // constant. + complete_type_id = eval_context.context().AsCompleteType( + complete_type_id, SemIR::LocId::Invalid, [&] { + CARBON_DIAGNOSTIC(IncompleteTypeInMonomorphization, Error, + "{0} evaluates to incomplete type {1}", + SemIR::TypeId, SemIR::TypeId); + return eval_context.emitter().Build( + inst_id, IncompleteTypeInMonomorphization, + require_complete.complete_type_id, complete_type_id); + }); + if (complete_type_id == SemIR::ErrorInst::SingletonTypeId) { + return SemIR::ErrorInst::SingletonConstantId; + } + return MakeConstantResult( + eval_context.context(), + SemIR::CompleteTypeWitness{ + .type_id = witness_type_id, + .object_repr_id = + eval_context.types().GetObjectRepr(complete_type_id)}, + phase); + } + + // If it's not a template constant, require it to be complete once it + // becomes one. + return MakeConstantResult( + eval_context.context(), + SemIR::RequireCompleteType{.type_id = witness_type_id, + .complete_type_id = complete_type_id}, + phase); + } + // These cases are either not expressions or not constant. case SemIR::AddrPattern::Kind: case SemIR::Assign::Kind: diff --git a/toolchain/check/function.cpp b/toolchain/check/function.cpp index d14973408cf4..50ef2d6cc013 100644 --- a/toolchain/check/function.cpp +++ b/toolchain/check/function.cpp @@ -65,7 +65,7 @@ auto CheckFunctionTypeMatches(Context& context, return true; } -auto CheckFunctionReturnType(Context& context, SemIRLoc loc, +auto CheckFunctionReturnType(Context& context, SemIR::LocId loc_id, SemIR::Function& function, SemIR::SpecificId specific_id) -> SemIR::ReturnTypeInfo { @@ -78,19 +78,19 @@ auto CheckFunctionReturnType(Context& context, SemIRLoc loc, auto diagnose_incomplete_return_type = [&] { CARBON_DIAGNOSTIC(IncompleteTypeInFunctionReturnType, Error, "function returns incomplete type {0}", SemIR::TypeId); - return context.emitter().Build(loc, IncompleteTypeInFunctionReturnType, + return context.emitter().Build(loc_id, IncompleteTypeInFunctionReturnType, return_info.type_id); }; auto diagnose_abstract_return_type = [&] { CARBON_DIAGNOSTIC(AbstractTypeInFunctionReturnType, Error, "function returns abstract type {0}", SemIR::TypeId); - return context.emitter().Build(loc, AbstractTypeInFunctionReturnType, + return context.emitter().Build(loc_id, AbstractTypeInFunctionReturnType, return_info.type_id); }; // TODO: Consider suppressing the diagnostic if we've already diagnosed a // definition or call to this function. - if (context.TryToCompleteType(return_info.type_id, + if (context.TryToCompleteType(return_info.type_id, loc_id, diagnose_incomplete_return_type, diagnose_abstract_return_type)) { return_info = SemIR::ReturnTypeInfo::ForFunction(context.sem_ir(), diff --git a/toolchain/check/function.h b/toolchain/check/function.h index a98199de9efa..3320bc5ffb61 100644 --- a/toolchain/check/function.h +++ b/toolchain/check/function.h @@ -39,7 +39,7 @@ auto CheckFunctionTypeMatches( // error if not. This computes the return slot usage for the function if // necessary, and returns information about how the function returns its return // value. -auto CheckFunctionReturnType(Context& context, SemIRLoc loc, +auto CheckFunctionReturnType(Context& context, SemIR::LocId loc_id, SemIR::Function& function, SemIR::SpecificId specific_id) -> SemIR::ReturnTypeInfo; diff --git a/toolchain/check/generic.cpp b/toolchain/check/generic.cpp index 3855fb25abc1..7f2c29738517 100644 --- a/toolchain/check/generic.cpp +++ b/toolchain/check/generic.cpp @@ -246,7 +246,6 @@ static auto MakeGenericEvalBlock(Context& context, SemIR::GenericId generic_id, // TODO: Eventually, completeness requirements should be modeled as // constraints on the generic rather than properties of the type. For now, // require the transformed type to be complete if the original was. - // TODO: We'll also need to do this when evaluating the eval block. if (context.types().IsComplete(inst.type_id())) { context.TryToCompleteType(type_id); } diff --git a/toolchain/check/handle_binding_pattern.cpp b/toolchain/check/handle_binding_pattern.cpp index 706cfcdd0a6d..93ac910a3153 100644 --- a/toolchain/check/handle_binding_pattern.cpp +++ b/toolchain/check/handle_binding_pattern.cpp @@ -104,7 +104,7 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id, // A `var` declaration at class scope introduces a field. auto parent_class_decl = context.GetCurrentScopeAs(); cast_type_id = context.AsCompleteType( - cast_type_id, + cast_type_id, type_node, [&] { CARBON_DIAGNOSTIC(IncompleteTypeInVarDecl, Error, "{0:field|variable} has incomplete type {1}", @@ -245,7 +245,7 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id, } case Parse::NodeKind::LetIntroducer: { - cast_type_id = context.AsCompleteType(cast_type_id, [&] { + cast_type_id = context.AsCompleteType(cast_type_id, type_node, [&] { CARBON_DIAGNOSTIC(IncompleteTypeInLetDecl, Error, "`let` binding has incomplete type {0}", InstIdAsType); diff --git a/toolchain/check/handle_class.cpp b/toolchain/check/handle_class.cpp index e751b99b280f..b60ba5b577f1 100644 --- a/toolchain/check/handle_class.cpp +++ b/toolchain/check/handle_class.cpp @@ -385,7 +385,7 @@ auto HandleParseNode(Context& context, Parse::AdaptDeclId node_id) -> bool { auto [adapted_inst_id, adapted_type_id] = ExprAsType(context, node_id, adapted_type_expr_id); adapted_type_id = context.AsCompleteType( - adapted_type_id, + adapted_type_id, node_id, [&] { CARBON_DIAGNOSTIC(IncompleteTypeInAdaptDecl, Error, "adapted type {0} is an incomplete type", @@ -457,7 +457,7 @@ static auto CheckBaseType(Context& context, Parse::NodeId node_id, SemIR::InstId base_expr_id) -> BaseInfo { auto [base_type_inst_id, base_type_id] = ExprAsType(context, node_id, base_expr_id); - base_type_id = context.AsCompleteType(base_type_id, [&] { + base_type_id = context.AsCompleteType(base_type_id, node_id, [&] { CARBON_DIAGNOSTIC(IncompleteTypeInBaseDecl, Error, "base {0} is an incomplete type", InstIdAsType); return context.emitter().Build(node_id, IncompleteTypeInBaseDecl, diff --git a/toolchain/check/handle_function.cpp b/toolchain/check/handle_function.cpp index 960f4a86865a..9740be7dee3a 100644 --- a/toolchain/check/handle_function.cpp +++ b/toolchain/check/handle_function.cpp @@ -331,16 +331,17 @@ auto HandleParseNode(Context& context, Parse::FunctionDeclId node_id) -> bool { static auto CheckFunctionDefinitionSignature(Context& context, SemIR::Function& function) -> void { - // Check the return type is complete. - CheckFunctionReturnType(context, function.return_slot_pattern_id, function, - SemIR::SpecificId::Invalid); - auto params_to_complete = context.inst_blocks().GetOrEmpty(function.call_params_id); + + // Check the return type is complete. if (function.return_slot_pattern_id.is_valid()) { - // Exclude the return slot because it's diagnosed above. + CheckFunctionReturnType( + context, context.insts().GetLocId(function.return_slot_pattern_id), + function, SemIR::SpecificId::Invalid); params_to_complete = params_to_complete.drop_back(); } + // Check the parameter types are complete. for (auto param_ref_id : params_to_complete) { if (param_ref_id == SemIR::ErrorInst::SingletonInstId) { @@ -349,7 +350,8 @@ static auto CheckFunctionDefinitionSignature(Context& context, // The parameter types need to be complete. context.TryToCompleteType( - context.insts().GetAs(param_ref_id).type_id, [&] { + context.insts().GetAs(param_ref_id).type_id, + context.insts().GetLocId(param_ref_id), [&] { CARBON_DIAGNOSTIC( IncompleteTypeInFunctionParam, Error, "parameter has incomplete type {0} in function definition", diff --git a/toolchain/check/handle_impl.cpp b/toolchain/check/handle_impl.cpp index 0d55083d7af9..861d15f76b07 100644 --- a/toolchain/check/handle_impl.cpp +++ b/toolchain/check/handle_impl.cpp @@ -179,7 +179,7 @@ static auto ExtendImpl(Context& context, Parse::NodeId extend_node, parent_scope.set_has_error(); return; } - if (!context.TryToDefineType(constraint_id, [&] { + if (!context.TryToDefineType(constraint_id, node_id, [&] { CARBON_DIAGNOSTIC( ExtendUndefinedInterface, Error, "`extend impl` requires a definition for facet type {0}", diff --git a/toolchain/check/impl.cpp b/toolchain/check/impl.cpp index b4139765d4ea..2af983185389 100644 --- a/toolchain/check/impl.cpp +++ b/toolchain/check/impl.cpp @@ -143,13 +143,15 @@ static auto BuildInterfaceWitness( // TODO: This is going to try and define all the interfaces for this facet // type, and so once we support impl of a facet type with more than one // interface, it might give the wrong name in the diagnostic. - if (!context.TryToDefineType(facet_type_id, [&] { - CARBON_DIAGNOSTIC(ImplOfUndefinedInterface, Error, - "implementation of undefined interface {0}", - SemIR::NameId); - return context.emitter().Build( - impl.definition_id, ImplOfUndefinedInterface, interface.name_id); - })) { + if (!context.TryToDefineType( + facet_type_id, context.insts().GetLocId(impl.definition_id), [&] { + CARBON_DIAGNOSTIC(ImplOfUndefinedInterface, Error, + "implementation of undefined interface {0}", + SemIR::NameId); + return context.emitter().Build(impl.definition_id, + ImplOfUndefinedInterface, + interface.name_id); + })) { return SemIR::ErrorInst::SingletonInstId; } diff --git a/toolchain/check/import_ref.cpp b/toolchain/check/import_ref.cpp index bbf8b12a6e3b..c585ed819359 100644 --- a/toolchain/check/import_ref.cpp +++ b/toolchain/check/import_ref.cpp @@ -2295,6 +2295,26 @@ static auto TryResolveTypedInst(ImportRefResolver& resolver, .pointee_id = pointee_type_id}); } +static auto TryResolveTypedInst(ImportRefResolver& resolver, + SemIR::RequireCompleteType inst) + -> ResolveResult { + CARBON_CHECK(resolver.import_types().GetInstId(inst.type_id) == + SemIR::WitnessType::SingletonInstId); + + auto complete_type_const_id = + GetLocalConstantId(resolver, inst.complete_type_id); + if (resolver.HasNewWork()) { + return ResolveResult::Retry(); + } + + auto complete_type_id = + resolver.local_context().GetTypeIdForTypeConstant(complete_type_const_id); + return ResolveAs( + resolver, {.type_id = resolver.local_context().GetSingletonType( + SemIR::WitnessType::SingletonInstId), + .complete_type_id = complete_type_id}); +} + static auto TryResolveTypedInst(ImportRefResolver& resolver, SemIR::SpecificFunction inst) -> ResolveResult { auto type_const_id = GetLocalConstantId(resolver, inst.type_id); @@ -2522,6 +2542,9 @@ static auto TryResolveInstCanonical(ImportRefResolver& resolver, case CARBON_KIND(SemIR::PointerType inst): { return TryResolveTypedInst(resolver, inst); } + case CARBON_KIND(SemIR::RequireCompleteType inst): { + return TryResolveTypedInst(resolver, inst); + } case CARBON_KIND(SemIR::SpecificFunction inst): { return TryResolveTypedInst(resolver, inst); } diff --git a/toolchain/check/member_access.cpp b/toolchain/check/member_access.cpp index 5ab658b94616..2128b9b80200 100644 --- a/toolchain/check/member_access.cpp +++ b/toolchain/check/member_access.cpp @@ -425,13 +425,15 @@ auto PerformMemberAccess(Context& context, SemIR::LocId loc_id, // If the base isn't a scope, it must have a complete type. auto base_type_id = context.insts().Get(base_id).type_id(); - if (!context.TryToCompleteType(base_type_id, [&] { - CARBON_DIAGNOSTIC(IncompleteTypeInMemberAccess, Error, - "member access into object of incomplete type {0}", - TypeOfInstId); - return context.emitter().Build(base_id, IncompleteTypeInMemberAccess, - base_id); - })) { + if (!context.TryToCompleteType( + base_type_id, context.insts().GetLocId(base_id), [&] { + CARBON_DIAGNOSTIC( + IncompleteTypeInMemberAccess, Error, + "member access into object of incomplete type {0}", + TypeOfInstId); + return context.emitter().Build( + base_id, IncompleteTypeInMemberAccess, base_id); + })) { return SemIR::ErrorInst::SingletonInstId; } diff --git a/toolchain/check/testdata/array/generic_empty.carbon b/toolchain/check/testdata/array/generic_empty.carbon index a2843f9ba234..b5cb4b349da1 100644 --- a/toolchain/check/testdata/array/generic_empty.carbon +++ b/toolchain/check/testdata/array/generic_empty.carbon @@ -23,6 +23,7 @@ fn G(T:! type) { // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %array_type: type = array_type %int_0, %T [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %array_type [symbolic] // CHECK:STDOUT: %array: %array_type = tuple_value () [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -54,6 +55,7 @@ fn G(T:! type) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %array_type.loc13_17.2: type = array_type constants.%int_0, @G.%T.loc11_6.2 (%T) [symbolic = %array_type.loc13_17.2 (constants.%array_type)] +// CHECK:STDOUT: %require_complete: = require_complete_type @G.%array_type.loc13_17.2 (%array_type) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %array: @G.%array_type.loc13_17.2 (%array_type) = tuple_value () [symbolic = %array (constants.%array)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { diff --git a/toolchain/check/testdata/as/adapter_conversion.carbon b/toolchain/check/testdata/as/adapter_conversion.carbon index 0273e44c1a81..2cd4c5077783 100644 --- a/toolchain/check/testdata/as/adapter_conversion.carbon +++ b/toolchain/check/testdata/as/adapter_conversion.carbon @@ -117,7 +117,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %Make.type: type = fn_type @Make [template] // CHECK:STDOUT: %Make: %Make.type = struct_value () [template] // CHECK:STDOUT: %struct_type.x.y.1: type = struct_type {.x: %i32, .y: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.y.1 [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] // CHECK:STDOUT: %struct_type.x.y.2: type = struct_type {.x: Core.IntLiteral, .y: Core.IntLiteral} [template] @@ -190,7 +190,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %return.param: ref %A = out_param runtime_param0 // CHECK:STDOUT: %return: ref %A = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -203,7 +203,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: class @B { // CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A] // CHECK:STDOUT: adapt_decl %A.ref [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%B @@ -289,7 +289,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %i32 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %i32 [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @As(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.7, @impl.5(%int_32) [template] @@ -331,7 +331,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %.loc5_12.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32] // CHECK:STDOUT: %.loc5_12.2: type = converted %int.make_type_signed, %.loc5_12.1 [template = constants.%i32] // CHECK:STDOUT: adapt_decl %.loc5_12.2 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %i32 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %i32 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -464,7 +464,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %A.elem: type = unbound_element_type %A, %i32 [template] // CHECK:STDOUT: %struct_type.x.y.1: type = struct_type {.x: %i32, .y: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.y.1 [template] // CHECK:STDOUT: %B: type = class_type @B [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] @@ -519,7 +519,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: %.loc6_10.1: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32] // CHECK:STDOUT: %.loc6_10.2: type = converted %int.make_type_signed.loc6, %.loc6_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc6_8: %A.elem = field_decl y, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -531,7 +531,7 @@ var b: B = {.x = 1} as B; // CHECK:STDOUT: class @B { // CHECK:STDOUT: %A.ref: type = name_ref A, file.%A.decl [template = constants.%A] // CHECK:STDOUT: adapt_decl %A.ref [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.y.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%B diff --git a/toolchain/check/testdata/as/overloaded.carbon b/toolchain/check/testdata/as/overloaded.carbon index d5b01468e613..a831731d918c 100644 --- a/toolchain/check/testdata/as/overloaded.carbon +++ b/toolchain/check/testdata/as/overloaded.carbon @@ -32,7 +32,7 @@ let n: i32 = ((4 as i32) as X) as i32; // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %X.elem: type = unbound_element_type %X, %i32 [template] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.n [template] // CHECK:STDOUT: %As.type.1: type = generic_interface_type @As [template] // CHECK:STDOUT: %As.generic: %As.type.1 = struct_value () [template] // CHECK:STDOUT: %As.type.3: type = facet_type <@As, @As(%X)> [template] @@ -153,7 +153,7 @@ let n: i32 = ((4 as i32) as X) as i32; // CHECK:STDOUT: %.loc12_10.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32] // CHECK:STDOUT: %.loc12_10.2: type = converted %int.make_type_signed, %.loc12_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc12_8: %X.elem = field_decl n, element0 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%X diff --git a/toolchain/check/testdata/basics/no_prelude/raw_ir.carbon b/toolchain/check/testdata/basics/no_prelude/raw_ir.carbon index b9a88d94862b..6eead5ca98af 100644 --- a/toolchain/check/testdata/basics/no_prelude/raw_ir.carbon +++ b/toolchain/check/testdata/basics/no_prelude/raw_ir.carbon @@ -45,6 +45,7 @@ fn Foo[T:! type](n: T) -> (T, ()) { // CHECK:STDOUT: 'type(symbolic_constant0)': {kind: copy, type: type(symbolic_constant0)} // CHECK:STDOUT: 'type(symbolic_constant2)': {kind: pointer, type: type(symbolic_constant6)} // CHECK:STDOUT: 'type(symbolic_constant6)': {kind: copy, type: type(symbolic_constant6)} +// CHECK:STDOUT: 'type(inst(WitnessType))': {kind: copy, type: type(inst(WitnessType))} // CHECK:STDOUT: 'type(symbolic_constant3)': {kind: copy, type: type(symbolic_constant3)} // CHECK:STDOUT: 'type(symbolic_constant5)': {kind: pointer, type: type(symbolic_constant6)} // CHECK:STDOUT: type_blocks: @@ -90,18 +91,26 @@ fn Foo[T:! type](n: T) -> (T, ()) { // CHECK:STDOUT: inst40: {kind: FunctionType, arg0: function0, arg1: specific, type: type(TypeType)} // CHECK:STDOUT: inst41: {kind: StructValue, arg0: inst_block_empty, type: type(inst40)} // CHECK:STDOUT: inst42: {kind: PointerType, arg0: type(symbolic_constant2), type: type(TypeType)} -// CHECK:STDOUT: inst43: {kind: NameRef, arg0: name2, arg1: inst19, type: type(symbolic_constant3)} -// CHECK:STDOUT: inst44: {kind: TupleLiteral, arg0: inst_block_empty, type: type(inst23)} -// CHECK:STDOUT: inst45: {kind: TupleLiteral, arg0: inst_block15, type: type(symbolic_constant5)} -// CHECK:STDOUT: inst46: {kind: TupleAccess, arg0: inst35, arg1: element0, type: type(symbolic_constant3)} -// CHECK:STDOUT: inst47: {kind: InitializeFrom, arg0: inst43, arg1: inst46, type: type(symbolic_constant3)} -// CHECK:STDOUT: inst48: {kind: TupleAccess, arg0: inst35, arg1: element1, type: type(inst23)} -// CHECK:STDOUT: inst49: {kind: TupleInit, arg0: inst_block_empty, arg1: inst48, type: type(inst23)} -// CHECK:STDOUT: inst50: {kind: TupleValue, arg0: inst_block_empty, type: type(inst23)} -// CHECK:STDOUT: inst51: {kind: Converted, arg0: inst44, arg1: inst49, type: type(inst23)} -// CHECK:STDOUT: inst52: {kind: TupleInit, arg0: inst_block16, arg1: inst35, type: type(symbolic_constant5)} -// CHECK:STDOUT: inst53: {kind: Converted, arg0: inst45, arg1: inst52, type: type(symbolic_constant5)} -// CHECK:STDOUT: inst54: {kind: ReturnExpr, arg0: inst53, arg1: inst35} +// CHECK:STDOUT: inst43: {kind: RequireCompleteType, arg0: type(symbolic_constant2), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst44: {kind: RequireCompleteType, arg0: type(symbolic_constant2), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst45: {kind: RequireCompleteType, arg0: type(symbolic_constant3), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst46: {kind: RequireCompleteType, arg0: type(symbolic_constant0), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst47: {kind: NameRef, arg0: name2, arg1: inst19, type: type(symbolic_constant3)} +// CHECK:STDOUT: inst48: {kind: TupleLiteral, arg0: inst_block_empty, type: type(inst23)} +// CHECK:STDOUT: inst49: {kind: TupleLiteral, arg0: inst_block15, type: type(symbolic_constant5)} +// CHECK:STDOUT: inst50: {kind: RequireCompleteType, arg0: type(symbolic_constant5), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst51: {kind: TupleAccess, arg0: inst35, arg1: element0, type: type(symbolic_constant3)} +// CHECK:STDOUT: inst52: {kind: RequireCompleteType, arg0: type(symbolic_constant0), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst53: {kind: InitializeFrom, arg0: inst47, arg1: inst51, type: type(symbolic_constant3)} +// CHECK:STDOUT: inst54: {kind: TupleAccess, arg0: inst35, arg1: element1, type: type(inst23)} +// CHECK:STDOUT: inst55: {kind: TupleInit, arg0: inst_block_empty, arg1: inst54, type: type(inst23)} +// CHECK:STDOUT: inst56: {kind: TupleValue, arg0: inst_block_empty, type: type(inst23)} +// CHECK:STDOUT: inst57: {kind: Converted, arg0: inst48, arg1: inst55, type: type(inst23)} +// CHECK:STDOUT: inst58: {kind: TupleInit, arg0: inst_block16, arg1: inst35, type: type(symbolic_constant5)} +// CHECK:STDOUT: inst59: {kind: Converted, arg0: inst49, arg1: inst58, type: type(symbolic_constant5)} +// CHECK:STDOUT: inst60: {kind: ReturnExpr, arg0: inst59, arg1: inst35} +// CHECK:STDOUT: inst61: {kind: RequireCompleteType, arg0: type(symbolic_constant5), type: type(inst(WitnessType))} +// CHECK:STDOUT: inst62: {kind: RequireCompleteType, arg0: type(symbolic_constant3), type: type(inst(WitnessType))} // CHECK:STDOUT: constant_values: // CHECK:STDOUT: inst12: template_constant(inst12) // CHECK:STDOUT: inst13: symbolic_constant3 @@ -123,9 +132,17 @@ fn Foo[T:! type](n: T) -> (T, ()) { // CHECK:STDOUT: inst40: template_constant(inst40) // CHECK:STDOUT: inst41: template_constant(inst41) // CHECK:STDOUT: inst42: symbolic_constant6 -// CHECK:STDOUT: inst49: template_constant(inst50) -// CHECK:STDOUT: inst50: template_constant(inst50) -// CHECK:STDOUT: inst51: template_constant(inst50) +// CHECK:STDOUT: inst43: symbolic_constant9 +// CHECK:STDOUT: inst44: symbolic_constant7 +// CHECK:STDOUT: inst45: symbolic_constant10 +// CHECK:STDOUT: inst46: symbolic_constant8 +// CHECK:STDOUT: inst50: symbolic_constant9 +// CHECK:STDOUT: inst52: symbolic_constant10 +// CHECK:STDOUT: inst55: template_constant(inst56) +// CHECK:STDOUT: inst56: template_constant(inst56) +// CHECK:STDOUT: inst57: template_constant(inst56) +// CHECK:STDOUT: inst61: symbolic_constant9 +// CHECK:STDOUT: inst62: symbolic_constant10 // CHECK:STDOUT: symbolic_constants: // CHECK:STDOUT: symbolic_constant0: {inst: inst14, generic: generic, index: generic_inst, .Self: false} // CHECK:STDOUT: symbolic_constant1: {inst: inst16, generic: generic, index: generic_inst, .Self: false} @@ -134,6 +151,10 @@ fn Foo[T:! type](n: T) -> (T, ()) { // CHECK:STDOUT: symbolic_constant4: {inst: inst16, generic: generic0, index: generic_inst_in_decl1, .Self: false} // CHECK:STDOUT: symbolic_constant5: {inst: inst28, generic: generic0, index: generic_inst_in_decl2, .Self: false} // CHECK:STDOUT: symbolic_constant6: {inst: inst42, generic: generic, index: generic_inst, .Self: false} +// CHECK:STDOUT: symbolic_constant7: {inst: inst44, generic: generic, index: generic_inst, .Self: false} +// CHECK:STDOUT: symbolic_constant8: {inst: inst46, generic: generic, index: generic_inst, .Self: false} +// CHECK:STDOUT: symbolic_constant9: {inst: inst44, generic: generic0, index: generic_inst_in_def0, .Self: false} +// CHECK:STDOUT: symbolic_constant10: {inst: inst46, generic: generic0, index: generic_inst_in_def1, .Self: false} // CHECK:STDOUT: inst_blocks: // CHECK:STDOUT: inst_block_empty: {} // CHECK:STDOUT: exports: @@ -183,24 +204,27 @@ fn Foo[T:! type](n: T) -> (T, ()) { // CHECK:STDOUT: 1: inst14 // CHECK:STDOUT: 2: inst28 // CHECK:STDOUT: inst_block14: -// CHECK:STDOUT: 0: inst43 -// CHECK:STDOUT: 1: inst44 -// CHECK:STDOUT: 2: inst45 -// CHECK:STDOUT: 3: inst46 -// CHECK:STDOUT: 4: inst47 -// CHECK:STDOUT: 5: inst48 -// CHECK:STDOUT: 6: inst49 -// CHECK:STDOUT: 7: inst51 -// CHECK:STDOUT: 8: inst52 -// CHECK:STDOUT: 9: inst53 -// CHECK:STDOUT: 10: inst54 -// CHECK:STDOUT: inst_block15: -// CHECK:STDOUT: 0: inst43 -// CHECK:STDOUT: 1: inst44 -// CHECK:STDOUT: inst_block16: // CHECK:STDOUT: 0: inst47 -// CHECK:STDOUT: 1: inst51 +// CHECK:STDOUT: 1: inst48 +// CHECK:STDOUT: 2: inst49 +// CHECK:STDOUT: 3: inst51 +// CHECK:STDOUT: 4: inst53 +// CHECK:STDOUT: 5: inst54 +// CHECK:STDOUT: 6: inst55 +// CHECK:STDOUT: 7: inst57 +// CHECK:STDOUT: 8: inst58 +// CHECK:STDOUT: 9: inst59 +// CHECK:STDOUT: 10: inst60 +// CHECK:STDOUT: inst_block15: +// CHECK:STDOUT: 0: inst47 +// CHECK:STDOUT: 1: inst48 +// CHECK:STDOUT: inst_block16: +// CHECK:STDOUT: 0: inst53 +// CHECK:STDOUT: 1: inst57 // CHECK:STDOUT: inst_block17: +// CHECK:STDOUT: 0: inst61 +// CHECK:STDOUT: 1: inst62 +// CHECK:STDOUT: inst_block18: // CHECK:STDOUT: 0: inst12 // CHECK:STDOUT: 1: inst36 // CHECK:STDOUT: ... diff --git a/toolchain/check/testdata/builtins/int/eq.carbon b/toolchain/check/testdata/builtins/int/eq.carbon index e6439e699f97..1859c8b8718f 100644 --- a/toolchain/check/testdata/builtins/int/eq.carbon +++ b/toolchain/check/testdata/builtins/int/eq.carbon @@ -46,7 +46,7 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq"; // CHECK:STDOUT: %Eq: %Eq.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -158,7 +158,7 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq"; // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -166,7 +166,7 @@ fn WrongResult(a: i32, b: i32) -> i32 = "int.eq"; // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/builtins/int/greater.carbon b/toolchain/check/testdata/builtins/int/greater.carbon index efdf91f164f1..1424735e65d2 100644 --- a/toolchain/check/testdata/builtins/int/greater.carbon +++ b/toolchain/check/testdata/builtins/int/greater.carbon @@ -43,7 +43,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: %Negate: %Negate.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -180,7 +180,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -188,7 +188,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/builtins/int/greater_eq.carbon b/toolchain/check/testdata/builtins/int/greater_eq.carbon index ae9b5ff0d4a7..834e7811de0a 100644 --- a/toolchain/check/testdata/builtins/int/greater_eq.carbon +++ b/toolchain/check/testdata/builtins/int/greater_eq.carbon @@ -43,7 +43,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: %Negate: %Negate.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -180,7 +180,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -188,7 +188,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/builtins/int/less.carbon b/toolchain/check/testdata/builtins/int/less.carbon index c4c683dc1050..d5abc7671e30 100644 --- a/toolchain/check/testdata/builtins/int/less.carbon +++ b/toolchain/check/testdata/builtins/int/less.carbon @@ -43,7 +43,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: %Negate: %Negate.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -180,7 +180,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -188,7 +188,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/builtins/int/less_eq.carbon b/toolchain/check/testdata/builtins/int/less_eq.carbon index 70c317b5007c..87f787350caf 100644 --- a/toolchain/check/testdata/builtins/int/less_eq.carbon +++ b/toolchain/check/testdata/builtins/int/less_eq.carbon @@ -43,7 +43,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: %Negate: %Negate.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -180,7 +180,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -188,7 +188,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/builtins/int/make_type_signed.carbon b/toolchain/check/testdata/builtins/int/make_type_signed.carbon index 5609130800a0..cd8315d1700e 100644 --- a/toolchain/check/testdata/builtins/int/make_type_signed.carbon +++ b/toolchain/check/testdata/builtins/int/make_type_signed.carbon @@ -160,6 +160,7 @@ var m: Int(1000000000); // CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic] // CHECK:STDOUT: %Symbolic.type: type = fn_type @Symbolic [template] // CHECK:STDOUT: %Symbolic: %Symbolic.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %iN [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -277,6 +278,7 @@ var m: Int(1000000000); // CHECK:STDOUT: %iN: type = int_type signed, %N.loc14_13.2 [symbolic = %iN (constants.%iN)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Symbolic.%iN (%iN) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%N.param_patt: Core.IntLiteral, %x.param_patt: @Symbolic.%iN (%iN)) -> @Symbolic.%iN (%iN) { // CHECK:STDOUT: !entry: @@ -317,7 +319,9 @@ var m: Int(1000000000); // CHECK:STDOUT: %N: Core.IntLiteral = bind_symbolic_name N, 0 [symbolic] // CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic] // CHECK:STDOUT: %N.patt: Core.IntLiteral = symbolic_binding_pattern N, 0 [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %iN [symbolic] // CHECK:STDOUT: %Symbolic.specific_fn: = specific_function %Symbolic, @Symbolic(%int_24) [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %i24 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -455,6 +459,7 @@ var m: Int(1000000000); // CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic = %iN (constants.%iN)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Symbolic.%iN (%iN) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%N.param_patt: Core.IntLiteral, %x.param_patt: @Symbolic.%iN (%iN)) -> @Symbolic.%iN (%iN); // CHECK:STDOUT: } @@ -471,6 +476,7 @@ var m: Int(1000000000); // CHECK:STDOUT: %iN => constants.%i24 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_zero_size.carbon diff --git a/toolchain/check/testdata/builtins/int/make_type_unsigned.carbon b/toolchain/check/testdata/builtins/int/make_type_unsigned.carbon index b1a9d7c49171..71f18dc5f50e 100644 --- a/toolchain/check/testdata/builtins/int/make_type_unsigned.carbon +++ b/toolchain/check/testdata/builtins/int/make_type_unsigned.carbon @@ -141,6 +141,7 @@ var m: UInt(1000000000); // CHECK:STDOUT: %uN: type = int_type unsigned, %N [symbolic] // CHECK:STDOUT: %Symbolic.type: type = fn_type @Symbolic [template] // CHECK:STDOUT: %Symbolic: %Symbolic.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %uN [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -258,6 +259,7 @@ var m: UInt(1000000000); // CHECK:STDOUT: %uN: type = int_type unsigned, %N.loc14_13.2 [symbolic = %uN (constants.%uN)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Symbolic.%uN (%uN) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%N.param_patt: Core.IntLiteral, %x.param_patt: @Symbolic.%uN (%uN)) -> @Symbolic.%uN (%uN) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/builtins/int/neq.carbon b/toolchain/check/testdata/builtins/int/neq.carbon index 6118640a869a..61fde3f19eb2 100644 --- a/toolchain/check/testdata/builtins/int/neq.carbon +++ b/toolchain/check/testdata/builtins/int/neq.carbon @@ -37,7 +37,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: %Neq: %Neq.type = struct_value () [template] // CHECK:STDOUT: %True: type = class_type @True [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %False: type = class_type @False [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] @@ -149,7 +149,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @True { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%True @@ -157,7 +157,7 @@ fn RuntimeCall(a: i32, b: i32) -> bool { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @False { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%False diff --git a/toolchain/check/testdata/class/access_modifers.carbon b/toolchain/check/testdata/class/access_modifers.carbon index 67efd1011a2e..f4e0fbf4cd24 100644 --- a/toolchain/check/testdata/class/access_modifers.carbon +++ b/toolchain/check/testdata/class/access_modifers.carbon @@ -167,7 +167,7 @@ class A { // CHECK:STDOUT: %Make.type: type = fn_type @Make [template] // CHECK:STDOUT: %Make: %Make.type = struct_value () [template] // CHECK:STDOUT: %struct_type.radius.1: type = struct_type {.radius: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius.1 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.radius.1 [template] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %Convert.bound.2: = bound_method %int_0.1, %Convert.14 [template] // CHECK:STDOUT: %Convert.specific_fn.2: = specific_function %Convert.bound.2, @Convert.2(%int_32) [template] @@ -235,7 +235,7 @@ class A { // CHECK:STDOUT: %return.param: ref %Circle = out_param runtime_param0 // CHECK:STDOUT: %return: ref %Circle = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius.1 [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Circle @@ -378,7 +378,7 @@ class A { // CHECK:STDOUT: %Compute.type: type = fn_type @Compute [template] // CHECK:STDOUT: %Compute: %Compute.type = struct_value () [template] // CHECK:STDOUT: %struct_type.radius: type = struct_type {.radius: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.radius [template] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -456,7 +456,7 @@ class A { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param1 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.radius [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Circle @@ -515,7 +515,7 @@ class A { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_5.2: %i32 = int_value 5 [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -554,7 +554,7 @@ class A { // CHECK:STDOUT: %.loc5_17.1: %i32 = value_of_initializer %int.convert_checked [template = constants.%int_5.2] // CHECK:STDOUT: %.loc5_17.2: %i32 = converted %int_5, %.loc5_17.1 [template = constants.%int_5.2] // CHECK:STDOUT: %x: %i32 = bind_name x, %.loc5_17.2 -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -587,7 +587,7 @@ class A { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_5.2: %i32 = int_value 5 [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -643,7 +643,7 @@ class A { // CHECK:STDOUT: %.loc6_25.1: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%int_5.2] // CHECK:STDOUT: %.loc6_25.2: %i32 = converted %int_5.loc6, %.loc6_25.1 [template = constants.%int_5.2] // CHECK:STDOUT: %y: %i32 = bind_name y, %.loc6_25.2 -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A diff --git a/toolchain/check/testdata/class/adapter/init_adapt.carbon b/toolchain/check/testdata/class/adapter/init_adapt.carbon index 9d0e1a9cb89c..3f29fae62ba2 100644 --- a/toolchain/check/testdata/class/adapter/init_adapt.carbon +++ b/toolchain/check/testdata/class/adapter/init_adapt.carbon @@ -101,7 +101,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.elem: type = unbound_element_type %C, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %AdaptC: type = class_type @AdaptC [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] @@ -186,7 +186,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %.loc6_10.1: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32] // CHECK:STDOUT: %.loc6_10.2: type = converted %int.make_type_signed.loc6, %.loc6_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc6_8: %C.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -198,7 +198,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: class @AdaptC { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] // CHECK:STDOUT: adapt_decl %C.ref [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%AdaptC @@ -271,7 +271,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.elem: type = unbound_element_type %C, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %AdaptC: type = class_type @AdaptC [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] @@ -356,7 +356,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: %.loc6_10.1: type = value_of_initializer %int.make_type_signed.loc6 [template = constants.%i32] // CHECK:STDOUT: %.loc6_10.2: type = converted %int.make_type_signed.loc6, %.loc6_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc6_8: %C.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -368,7 +368,7 @@ var e: C = MakeAdaptC(); // CHECK:STDOUT: class @AdaptC { // CHECK:STDOUT: %C.ref: type = name_ref C, file.%C.decl [template = constants.%C] // CHECK:STDOUT: adapt_decl %C.ref [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%AdaptC diff --git a/toolchain/check/testdata/class/base_method.carbon b/toolchain/check/testdata/class/base_method.carbon index f72f7dedc6a4..b2907d2d4fad 100644 --- a/toolchain/check/testdata/class/base_method.carbon +++ b/toolchain/check/testdata/class/base_method.carbon @@ -52,7 +52,7 @@ fn Call(p: Derived*) { // CHECK:STDOUT: %Derived: type = class_type @Derived [template] // CHECK:STDOUT: %Derived.elem: type = unbound_element_type %Derived, %Base [template] // CHECK:STDOUT: %struct_type.base.1: type = struct_type {.base: %Base} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.base.1 [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.base.1 [template] // CHECK:STDOUT: %ptr.3: type = ptr_type %Derived [template] // CHECK:STDOUT: %Call.type: type = fn_type @Call [template] // CHECK:STDOUT: %Call: %Call.type = struct_value () [template] @@ -126,7 +126,7 @@ fn Call(p: Derived*) { // CHECK:STDOUT: class @Derived { // CHECK:STDOUT: %Base.ref: type = name_ref Base, file.%Base.decl [template = constants.%Base] // CHECK:STDOUT: %.loc22: %Derived.elem = base_decl %Base.ref, element0 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.base.1 [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.base.1 [template = constants.%complete_type.4] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Derived diff --git a/toolchain/check/testdata/class/basic.carbon b/toolchain/check/testdata/class/basic.carbon index 10c2ac6cd4ac..0eee260bce2b 100644 --- a/toolchain/check/testdata/class/basic.carbon +++ b/toolchain/check/testdata/class/basic.carbon @@ -40,7 +40,7 @@ fn Run() -> i32 { // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.k: type = struct_type {.k: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.k [template] // CHECK:STDOUT: %Run.type: type = fn_type @Run [template] // CHECK:STDOUT: %Run: %Run.type = struct_value () [template] // CHECK:STDOUT: %int_4.1: Core.IntLiteral = int_value 4 [template] @@ -150,7 +150,7 @@ fn Run() -> i32 { // CHECK:STDOUT: %.loc18_10.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32] // CHECK:STDOUT: %.loc18_10.2: type = converted %int.make_type_signed, %.loc18_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc18_8: %Class.elem = field_decl k, element0 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/fail_abstract.carbon b/toolchain/check/testdata/class/fail_abstract.carbon index a977a81a36cf..410dcef16b33 100644 --- a/toolchain/check/testdata/class/fail_abstract.carbon +++ b/toolchain/check/testdata/class/fail_abstract.carbon @@ -178,7 +178,7 @@ fn ReturnAbstract() -> Abstract; fn CallReturnAbstract() { // CHECK:STDERR: fail_call_abstract_return.carbon:[[@LINE+9]]:3: error: function returns abstract type `Abstract` [AbstractTypeInFunctionReturnType] // CHECK:STDERR: ReturnAbstract(); - // CHECK:STDERR: ^~~~~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_call_abstract_return.carbon:[[@LINE-9]]:1: note: class was declared abstract here [ClassAbstractHere] // CHECK:STDERR: abstract class Abstract { // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/toolchain/check/testdata/class/fail_field_modifiers.carbon b/toolchain/check/testdata/class/fail_field_modifiers.carbon index 9008ecd88dc0..9277231dc92a 100644 --- a/toolchain/check/testdata/class/fail_field_modifiers.carbon +++ b/toolchain/check/testdata/class/fail_field_modifiers.carbon @@ -56,7 +56,7 @@ class Class { // CHECK:STDOUT: %Convert.specific_fn.2: = specific_function %Convert.bound.2, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_1.2: %i32 = int_value 1 [template] // CHECK:STDOUT: %struct_type.j.k: type = struct_type {.j: %i32, .k: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.j.k [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -112,7 +112,7 @@ class Class { // CHECK:STDOUT: %.loc34_23.1: %i32 = value_of_initializer %int.convert_checked.loc34 [template = constants.%int_1.2] // CHECK:STDOUT: %.loc34_23.2: %i32 = converted %int_1, %.loc34_23.1 [template = constants.%int_1.2] // CHECK:STDOUT: %m: %i32 = bind_name m, %.loc34_23.2 -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/fail_generic_method.carbon b/toolchain/check/testdata/class/fail_generic_method.carbon index 8b85b0ac647c..699ee973995c 100644 --- a/toolchain/check/testdata/class/fail_generic_method.carbon +++ b/toolchain/check/testdata/class/fail_generic_method.carbon @@ -39,6 +39,7 @@ fn Class(N:! i32).F[self: Self](n: T) {} // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F, @Class(%T) [symbolic] // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] @@ -101,6 +102,7 @@ fn Class(N:! i32).F[self: Self](n: T) {} // CHECK:STDOUT: %T.patt.loc11_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc11_13.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc11_13.2) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.loc11_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %F.type: type = fn_type @F, @Class(%T.loc11_13.2) [symbolic = %F.type (constants.%F.type)] diff --git a/toolchain/check/testdata/class/fail_incomplete.carbon b/toolchain/check/testdata/class/fail_incomplete.carbon index 9dac1fc844db..b21382bba518 100644 --- a/toolchain/check/testdata/class/fail_incomplete.carbon +++ b/toolchain/check/testdata/class/fail_incomplete.carbon @@ -129,7 +129,7 @@ fn CallTakeIncomplete(p: Class*) { fn CallReturnIncomplete() { // CHECK:STDERR: fail_forward_decl.carbon:[[@LINE+10]]:3: error: function returns incomplete type `Class` [IncompleteTypeInFunctionReturnType] // CHECK:STDERR: ReturnIncomplete(); - // CHECK:STDERR: ^~~~~~~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~ // CHECK:STDERR: fail_forward_decl.carbon:[[@LINE-118]]:1: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class Class; // CHECK:STDERR: ^~~~~~~~~~~~ diff --git a/toolchain/check/testdata/class/fail_init.carbon b/toolchain/check/testdata/class/fail_init.carbon index f03a06948cde..461a2839c873 100644 --- a/toolchain/check/testdata/class/fail_init.carbon +++ b/toolchain/check/testdata/class/fail_init.carbon @@ -40,7 +40,7 @@ fn F() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.a.b: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -89,7 +89,7 @@ fn F() { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %Class.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/fail_init_as_inplace.carbon b/toolchain/check/testdata/class/fail_init_as_inplace.carbon index 8d4fcb5cdcf1..85d03a93dba8 100644 --- a/toolchain/check/testdata/class/fail_init_as_inplace.carbon +++ b/toolchain/check/testdata/class/fail_init_as_inplace.carbon @@ -37,7 +37,7 @@ fn F() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %ptr.1: type = ptr_type %Class [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] @@ -100,7 +100,7 @@ fn F() { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %Class.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/fail_scope.carbon b/toolchain/check/testdata/class/fail_scope.carbon index 8f7dcfd9accb..dae0ca2e4bd4 100644 --- a/toolchain/check/testdata/class/fail_scope.carbon +++ b/toolchain/check/testdata/class/fail_scope.carbon @@ -32,7 +32,7 @@ fn G() -> i32 { // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -87,7 +87,7 @@ fn G() -> i32 { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/field_access.carbon b/toolchain/check/testdata/class/field_access.carbon index 18fad2c4a69d..9d43cd28cd1a 100644 --- a/toolchain/check/testdata/class/field_access.carbon +++ b/toolchain/check/testdata/class/field_access.carbon @@ -31,7 +31,7 @@ fn Run() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.j.k: type = struct_type {.j: %i32, .k: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.j.k [template] // CHECK:STDOUT: %Run.type: type = fn_type @Run [template] // CHECK:STDOUT: %Run: %Run.type = struct_value () [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -79,7 +79,7 @@ fn Run() { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %Class.elem = field_decl k, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/field_access_in_value.carbon b/toolchain/check/testdata/class/field_access_in_value.carbon index 7f03770b2aa0..9361826dc84b 100644 --- a/toolchain/check/testdata/class/field_access_in_value.carbon +++ b/toolchain/check/testdata/class/field_access_in_value.carbon @@ -32,7 +32,7 @@ fn Test() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.j.k: type = struct_type {.j: %i32, .k: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.j.k [template] // CHECK:STDOUT: %Test.type: type = fn_type @Test [template] // CHECK:STDOUT: %Test: %Test.type = struct_value () [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -80,7 +80,7 @@ fn Test() { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %Class.elem = field_decl k, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.j.k [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/generic/adapt.carbon b/toolchain/check/testdata/class/generic/adapt.carbon index 56fdfca51017..222c8b49d787 100644 --- a/toolchain/check/testdata/class/generic/adapt.carbon +++ b/toolchain/check/testdata/class/generic/adapt.carbon @@ -128,6 +128,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %T [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] @@ -137,9 +138,10 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %i32 [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.2 [template] // CHECK:STDOUT: %Access.type: type = fn_type @Access [template] // CHECK:STDOUT: %Access: %Access.type = struct_value () [template] // CHECK:STDOUT: } @@ -191,6 +193,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_9.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T.loc4_9.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T.loc4_9.2) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%T.loc4_9.2 (%T) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @C.%T.loc4_9.2 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -216,7 +219,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %.loc9_14.2: type = converted %int.make_type_signed, %.loc9_14.1 [template = constants.%i32] // CHECK:STDOUT: %C: type = class_type @C, @C(constants.%i32) [template = constants.%C.2] // CHECK:STDOUT: adapt_decl %C [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Adapter @@ -255,10 +258,11 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_9.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 -// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- import_adapt_specific_type.carbon @@ -277,7 +281,9 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] // CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %T [symbolic] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %i32 [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %i32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -298,7 +304,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %import_ref.5 = import_ref Main//adapt_specific_type, inst27 [no loc], unloaded // CHECK:STDOUT: %import_ref.6: @C.%C.elem (%C.elem.1) = import_ref Main//adapt_specific_type, loc5_8, loaded [template = %.1] // CHECK:STDOUT: %import_ref.8: = import_ref Main//adapt_specific_type, loc10_1, loaded [template = constants.%complete_type.2] -// CHECK:STDOUT: %import_ref.9 = import_ref Main//adapt_specific_type, inst39 [no loc], unloaded +// CHECK:STDOUT: %import_ref.9 = import_ref Main//adapt_specific_type, inst42 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -340,6 +346,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%T (%T) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @C.%T (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -380,6 +387,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 @@ -399,6 +407,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %T [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] @@ -408,9 +417,10 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %i32 [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.2 [template] // CHECK:STDOUT: %Access.type: type = fn_type @Access [template] // CHECK:STDOUT: %Access: %Access.type = struct_value () [template] // CHECK:STDOUT: } @@ -463,6 +473,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_9.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T.loc4_9.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T.loc4_9.2) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%T.loc4_9.2 (%T) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @C.%T.loc4_9.2 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -488,7 +499,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %.loc9_21.2: type = converted %int.make_type_signed, %.loc9_21.1 [template = constants.%i32] // CHECK:STDOUT: %C: type = class_type @C, @C(constants.%i32) [template = constants.%C.2] // CHECK:STDOUT: adapt_decl %C [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Adapter @@ -520,10 +531,11 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_9.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 -// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- extend_adapt_specific_type_library.carbon @@ -534,6 +546,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %T [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] @@ -543,9 +556,10 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %i32 [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -578,6 +592,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc7_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc7_9.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T.loc7_9.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T.loc7_9.2) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%T.loc7_9.2 (%T) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @C.%T.loc7_9.2 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -603,7 +618,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %.loc12_21.2: type = converted %int.make_type_signed, %.loc12_21.1 [template = constants.%i32] // CHECK:STDOUT: %C: type = class_type @C, @C(constants.%i32) [template = constants.%C.2] // CHECK:STDOUT: adapt_decl %C [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.x.2 [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Adapter @@ -626,10 +641,11 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc7_9.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 -// CHECK:STDOUT: %complete_type.loc9_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc9_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_import_extend_adapt_specific_type.carbon @@ -646,7 +662,9 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] // CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %T [symbolic] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %i32 [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %i32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -667,7 +685,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %import_ref.4 = import_ref Main//extend_adapt_specific_type_library, inst27 [no loc], unloaded // CHECK:STDOUT: %import_ref.5: @C.%C.elem (%C.elem.1) = import_ref Main//extend_adapt_specific_type_library, loc8_8, loaded [template = %.1] // CHECK:STDOUT: %import_ref.7: = import_ref Main//extend_adapt_specific_type_library, loc13_1, loaded [template = constants.%complete_type.2] -// CHECK:STDOUT: %import_ref.8 = import_ref Main//extend_adapt_specific_type_library, inst39 [no loc], unloaded +// CHECK:STDOUT: %import_ref.8 = import_ref Main//extend_adapt_specific_type_library, inst42 [no loc], unloaded // CHECK:STDOUT: %import_ref.9: type = import_ref Main//extend_adapt_specific_type_library, loc12_21, loaded [template = constants.%C.2] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -710,6 +728,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%T (%T) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @C.%T (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -742,6 +761,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 @@ -761,6 +781,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %Adapter.type: type = generic_class_type @Adapter [template] // CHECK:STDOUT: %Adapter.generic: %Adapter.type = struct_value () [template] // CHECK:STDOUT: %Adapter.1: type = class_type @Adapter, @Adapter(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %T [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -822,6 +843,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_15.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_15.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Adapter.%T.loc4_15.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %complete_type.loc6_1.2: = complete_type_witness @Adapter.%T.loc4_15.2 (%T) [symbolic = %complete_type.loc6_1.2 (constants.%complete_type.1)] // CHECK:STDOUT: // CHECK:STDOUT: class { @@ -857,6 +879,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_15.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -868,6 +891,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %T [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -956,6 +980,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Adapter.%T (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %complete_type: = complete_type_witness @Adapter.%T (%T) [symbolic = %complete_type (constants.%complete_type.1)] // CHECK:STDOUT: // CHECK:STDOUT: class { @@ -1013,6 +1038,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %complete_type => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1021,6 +1047,7 @@ fn ImportedConvertLocal(a: Adapter(C)) -> i32 { // CHECK:STDOUT: %T.patt => constants.%C // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %complete_type => constants.%complete_type.4 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/base_is_generic.carbon b/toolchain/check/testdata/class/generic/base_is_generic.carbon index adb04b35b389..4f9da912f1a1 100644 --- a/toolchain/check/testdata/class/generic/base_is_generic.carbon +++ b/toolchain/check/testdata/class/generic/base_is_generic.carbon @@ -92,6 +92,7 @@ fn H() { // CHECK:STDOUT: %Base.type: type = generic_class_type @Base [template] // CHECK:STDOUT: %Base.generic: %Base.type = struct_value () [template] // CHECK:STDOUT: %Base.1: type = class_type @Base, @Base(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Base.elem.1: type = unbound_element_type %Base.1, %T [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] @@ -164,6 +165,7 @@ fn H() { // CHECK:STDOUT: %T.patt.loc4_17.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_17.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Base.%T.loc4_17.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T.loc4_17.2) [symbolic = %Base (constants.%Base.1)] // CHECK:STDOUT: %Base.elem: type = unbound_element_type @Base.%Base (%Base.1), @Base.%T.loc4_17.2 (%T) [symbolic = %Base.elem (constants.%Base.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @Base.%T.loc4_17.2 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -237,6 +239,7 @@ fn H() { // CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%Param // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Base => constants.%Base.2 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 @@ -260,6 +263,7 @@ fn H() { // CHECK:STDOUT: %Base.2: type = class_type @Base, @Base(%Param) [template] // CHECK:STDOUT: %struct_type.base.1: type = struct_type {.base: %Base.2} [template] // CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.base.1 [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Base.elem.1: type = unbound_element_type %Base.1, %T [symbolic] // CHECK:STDOUT: %Base.elem.2: type = unbound_element_type %Base.2, %Param [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %Param} [template] @@ -282,13 +286,13 @@ fn H() { // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } // CHECK:STDOUT: %import_ref.5: = import_ref Main//extend_generic_base, loc10_1, loaded [template = constants.%complete_type.1] -// CHECK:STDOUT: %import_ref.6 = import_ref Main//extend_generic_base, inst39 [no loc], unloaded +// CHECK:STDOUT: %import_ref.6 = import_ref Main//extend_generic_base, inst42 [no loc], unloaded // CHECK:STDOUT: %import_ref.7: %Param.elem = import_ref Main//extend_generic_base, loc9_8, loaded [template = %.1] // CHECK:STDOUT: %import_ref.8: = import_ref Main//extend_generic_base, loc6_1, loaded [symbolic = @Base.%complete_type (constants.%complete_type.2)] // CHECK:STDOUT: %import_ref.9 = import_ref Main//extend_generic_base, inst27 [no loc], unloaded // CHECK:STDOUT: %import_ref.10: @Base.%Base.elem (%Base.elem.1) = import_ref Main//extend_generic_base, loc5_8, loaded [template = %.2] // CHECK:STDOUT: %import_ref.12: = import_ref Main//extend_generic_base, loc14_1, loaded [template = constants.%complete_type.3] -// CHECK:STDOUT: %import_ref.13 = import_ref Main//extend_generic_base, inst60 [no loc], unloaded +// CHECK:STDOUT: %import_ref.13 = import_ref Main//extend_generic_base, inst63 [no loc], unloaded // CHECK:STDOUT: %import_ref.14 = import_ref Main//extend_generic_base, loc13_27, unloaded // CHECK:STDOUT: %import_ref.15: type = import_ref Main//extend_generic_base, loc13_26, loaded [template = constants.%Base.2] // CHECK:STDOUT: } @@ -342,6 +346,7 @@ fn H() { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Base.%T (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T) [symbolic = %Base (constants.%Base.1)] // CHECK:STDOUT: %Base.elem: type = unbound_element_type @Base.%Base (%Base.1), @Base.%T (%T) [symbolic = %Base.elem (constants.%Base.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @Base.%T (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -378,6 +383,7 @@ fn H() { // CHECK:STDOUT: %T.patt => constants.%Param // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: %Base => constants.%Base.2 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 @@ -397,6 +403,7 @@ fn H() { // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %X: type = class_type @X [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] @@ -438,6 +445,7 @@ fn H() { // CHECK:STDOUT: %T.patt.loc4_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_9.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%T.loc4_9.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: class { // CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc4_9.1 [symbolic = %T.loc4_9.2 (constants.%T)] @@ -486,6 +494,7 @@ fn H() { // CHECK:STDOUT: %T.patt.loc4_9.2 => constants.%X // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- extend_generic_symbolic_base.carbon @@ -500,6 +509,7 @@ fn H() { // CHECK:STDOUT: %G.1: %G.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %U [symbolic] // CHECK:STDOUT: %G.specific_fn.1: = specific_function %G.1, @G(%U) [symbolic] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] @@ -509,6 +519,7 @@ fn H() { // CHECK:STDOUT: %X.2: type = class_type @X, @X(%T) [symbolic] // CHECK:STDOUT: %G.type.2: type = fn_type @G, @X(%T) [symbolic] // CHECK:STDOUT: %G.2: %G.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %X.2 [symbolic] // CHECK:STDOUT: %C.elem.1: type = unbound_element_type %C.1, %X.2 [symbolic] // CHECK:STDOUT: %struct_type.base.1: type = struct_type {.base: %X.2} [symbolic] // CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.base.1 [symbolic] @@ -520,12 +531,13 @@ fn H() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] // CHECK:STDOUT: %X.3: type = class_type @X, @X(%i32) [template] +// CHECK:STDOUT: %G.type.3: type = fn_type @G, @X(%i32) [template] +// CHECK:STDOUT: %G.3: %G.type.3 = struct_value () [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %X.3 [template] // CHECK:STDOUT: %struct_type.base.2: type = struct_type {.base: %X.3} [template] // CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.base.2 [template] -// CHECK:STDOUT: %G.type.3: type = fn_type @G, @X(%i32) [template] -// CHECK:STDOUT: %G.3: %G.type.3 = struct_value () [template] // CHECK:STDOUT: %G.specific_fn.2: = specific_function %G.3, @G(%i32) [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -593,6 +605,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %X.loc9_19.2: type = class_type @X, @X(%T.loc8_9.2) [symbolic = %X.loc9_19.2 (constants.%X.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%X.loc9_19.2 (%X.2) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T.loc8_9.2) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%X.loc9_19.2 (%X.2) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.base: type = struct_type {.base: @C.%X.loc9_19.2 (%X.2)} [symbolic = %struct_type.base (constants.%struct_type.base.1)] @@ -617,6 +630,7 @@ fn H() { // CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic = %U (constants.%U)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @G.%U (%U) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %G.type: type = fn_type @G, @X(%U) [symbolic = %G.type (constants.%G.type.1)] // CHECK:STDOUT: %G: @G.%G.type (%G.type.1) = struct_value () [symbolic = %G (constants.%G.1)] // CHECK:STDOUT: %G.specific_fn.loc5_24.2: = specific_function %G, @G(%U) [symbolic = %G.specific_fn.loc5_24.2 (constants.%G.specific_fn.1)] @@ -668,6 +682,7 @@ fn H() { // CHECK:STDOUT: %U => constants.%U // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %G.type => constants.%G.type.1 // CHECK:STDOUT: %G => constants.%G.1 // CHECK:STDOUT: %G.specific_fn.loc5_24.2 => constants.%G.specific_fn.1 @@ -717,6 +732,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %X.loc9_19.2 => constants.%X.3 +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.base => constants.%struct_type.base.2 @@ -736,6 +752,7 @@ fn H() { // CHECK:STDOUT: %U => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.4 // CHECK:STDOUT: %G.type => constants.%G.type.3 // CHECK:STDOUT: %G => constants.%G.3 // CHECK:STDOUT: %G.specific_fn.loc5_24.2 => constants.%G.specific_fn.2 @@ -765,17 +782,20 @@ fn H() { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %G.type.1: type = fn_type @G, @X(%U) [symbolic] // CHECK:STDOUT: %G.1: %G.type.1 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %X.2 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %U [symbolic] // CHECK:STDOUT: %G.specific_fn.1: = specific_function %G.1, @G(%U) [symbolic] // CHECK:STDOUT: %G.type.2: type = fn_type @G, @X(%T) [symbolic] // CHECK:STDOUT: %G.2: %G.type.2 = struct_value () [symbolic] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%i32) [template] // CHECK:STDOUT: %X.3: type = class_type @X, @X(%i32) [template] +// CHECK:STDOUT: %G.type.3: type = fn_type @G, @X(%i32) [template] +// CHECK:STDOUT: %G.3: %G.type.3 = struct_value () [template] // CHECK:STDOUT: %C.elem.2: type = unbound_element_type %C.2, %X.3 [template] // CHECK:STDOUT: %struct_type.base.2: type = struct_type {.base: %X.3} [template] // CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.base.2 [template] -// CHECK:STDOUT: %G.type.3: type = fn_type @G, @X(%i32) [template] -// CHECK:STDOUT: %G.3: %G.type.3 = struct_value () [template] // CHECK:STDOUT: %G.specific_fn.2: = specific_function %G.3, @G(%i32) [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -791,7 +811,7 @@ fn H() { // CHECK:STDOUT: %import_ref.6 = import_ref Main//extend_generic_symbolic_base, inst27 [no loc], unloaded // CHECK:STDOUT: %import_ref.7: @X.%G.type (%G.type.1) = import_ref Main//extend_generic_symbolic_base, loc5_15, loaded [symbolic = @X.%G (constants.%G.1)] // CHECK:STDOUT: %import_ref.9: = import_ref Main//extend_generic_symbolic_base, loc10_1, loaded [symbolic = @C.%complete_type (constants.%complete_type.2)] -// CHECK:STDOUT: %import_ref.10 = import_ref Main//extend_generic_symbolic_base, inst64 [no loc], unloaded +// CHECK:STDOUT: %import_ref.10 = import_ref Main//extend_generic_symbolic_base, inst68 [no loc], unloaded // CHECK:STDOUT: %import_ref.11 = import_ref Main//extend_generic_symbolic_base, loc9_20, unloaded // CHECK:STDOUT: %import_ref.12: type = import_ref Main//extend_generic_symbolic_base, loc9_19, loaded [symbolic = @C.%X (constants.%X.2)] // CHECK:STDOUT: } @@ -815,6 +835,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %X: type = class_type @X, @X(%T) [symbolic = %X (constants.%X.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%X (%X.2) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %C: type = class_type @C, @C(%T) [symbolic = %C (constants.%C.1)] // CHECK:STDOUT: %C.elem: type = unbound_element_type @C.%C (%C.1), @C.%X (%X.2) [symbolic = %C.elem (constants.%C.elem.1)] // CHECK:STDOUT: %struct_type.base: type = struct_type {.base: @C.%X (%X.2)} [symbolic = %struct_type.base (constants.%struct_type.base.1)] @@ -871,6 +892,7 @@ fn H() { // CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic = %U (constants.%U)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @G.%U (%U) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %G.type: type = fn_type @G, @X(%U) [symbolic = %G.type (constants.%G.type.1)] // CHECK:STDOUT: %G: @G.%G.type (%G.type.1) = struct_value () [symbolic = %G (constants.%G.1)] // CHECK:STDOUT: %G.specific_fn: = specific_function %G, @G(%U) [symbolic = %G.specific_fn (constants.%G.specific_fn.1)] @@ -920,6 +942,7 @@ fn H() { // CHECK:STDOUT: %U => constants.%U // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.2 // CHECK:STDOUT: %G.type => constants.%G.type.1 // CHECK:STDOUT: %G => constants.%G.1 // CHECK:STDOUT: %G.specific_fn => constants.%G.specific_fn.1 @@ -940,6 +963,7 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %X => constants.%X.3 +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: %C => constants.%C.2 // CHECK:STDOUT: %C.elem => constants.%C.elem.2 // CHECK:STDOUT: %struct_type.base => constants.%struct_type.base.2 @@ -959,6 +983,7 @@ fn H() { // CHECK:STDOUT: %U => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.4 // CHECK:STDOUT: %G.type => constants.%G.type.3 // CHECK:STDOUT: %G => constants.%G.3 // CHECK:STDOUT: %G.specific_fn => constants.%G.specific_fn.2 diff --git a/toolchain/check/testdata/class/generic/basic.carbon b/toolchain/check/testdata/class/generic/basic.carbon index 33a104223ab3..c93191c8781e 100644 --- a/toolchain/check/testdata/class/generic/basic.carbon +++ b/toolchain/check/testdata/class/generic/basic.carbon @@ -37,9 +37,13 @@ class Declaration(T:! type); // CHECK:STDOUT: %GetAddr: %GetAddr.type = struct_value () [symbolic] // CHECK:STDOUT: %GetValue.type: type = fn_type @GetValue, @Class(%T) [symbolic] // CHECK:STDOUT: %GetValue: %GetValue.type = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %struct_type.k: type = struct_type {.k: %T} [symbolic] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.2 [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %ptr.1 [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %Class [symbolic] // CHECK:STDOUT: %Declaration.type: type = generic_class_type @Declaration [template] // CHECK:STDOUT: %Declaration.generic: %Declaration.type = struct_value () [template] // CHECK:STDOUT: } @@ -83,6 +87,7 @@ class Declaration(T:! type); // CHECK:STDOUT: %GetAddr: @Class.%GetAddr.type (%GetAddr.type) = struct_value () [symbolic = %GetAddr (constants.%GetAddr)] // CHECK:STDOUT: %GetValue.type: type = fn_type @GetValue, @Class(%T.loc11_13.2) [symbolic = %GetValue.type (constants.%GetValue.type)] // CHECK:STDOUT: %GetValue: @Class.%GetValue.type (%GetValue.type) = struct_value () [symbolic = %GetValue (constants.%GetValue)] +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc11_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc11_13.2) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.loc11_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %struct_type.k: type = struct_type {.k: @Class.%T.loc11_13.2 (%T)} [symbolic = %struct_type.k (constants.%struct_type.k)] @@ -147,6 +152,9 @@ class Declaration(T:! type); // CHECK:STDOUT: %ptr.loc12_38.1: type = ptr_type @GetAddr.%T (%T) [symbolic = %ptr.loc12_38.1 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc12_34: = require_complete_type @GetAddr.%ptr.loc12_38.1 (%ptr.2) [symbolic = %require_complete.loc12_34 (constants.%require_complete.2)] +// CHECK:STDOUT: %require_complete.loc12_23: = require_complete_type @GetAddr.%ptr.loc12_29.1 (%ptr.1) [symbolic = %require_complete.loc12_23 (constants.%require_complete.3)] +// CHECK:STDOUT: %require_complete.loc13: = require_complete_type @GetAddr.%Class (%Class) [symbolic = %require_complete.loc13 (constants.%require_complete.4)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @GetAddr.%Class (%Class), @GetAddr.%T (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: // CHECK:STDOUT: fn[addr %self.param_patt: @GetAddr.%ptr.loc12_29.1 (%ptr.1)]() -> @GetAddr.%ptr.loc12_38.1 (%ptr.2) { @@ -165,7 +173,9 @@ class Declaration(T:! type); // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc17: = require_complete_type @GetValue.%Class (%Class) [symbolic = %require_complete.loc17 (constants.%require_complete.4)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @GetValue.%Class (%Class), @GetValue.%T (%T) [symbolic = %Class.elem (constants.%Class.elem)] +// CHECK:STDOUT: %require_complete.loc18: = require_complete_type @GetValue.%T (%T) [symbolic = %require_complete.loc18 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @GetValue.%Class (%Class)]() -> @GetValue.%T (%T) { // CHECK:STDOUT: !entry: @@ -186,6 +196,7 @@ class Declaration(T:! type); // CHECK:STDOUT: %GetAddr => constants.%GetAddr // CHECK:STDOUT: %GetValue.type => constants.%GetValue.type // CHECK:STDOUT: %GetValue => constants.%GetValue +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %Class.elem => constants.%Class.elem // CHECK:STDOUT: %struct_type.k => constants.%struct_type.k diff --git a/toolchain/check/testdata/class/generic/call.carbon b/toolchain/check/testdata/class/generic/call.carbon index 23fe4f248d97..af27c369f048 100644 --- a/toolchain/check/testdata/class/generic/call.carbon +++ b/toolchain/check/testdata/class/generic/call.carbon @@ -101,7 +101,7 @@ class Outer(T:! type) { // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class.1: type = class_type @Class, @Class(%T, %N.1) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %ptr.1: type = ptr_type %i32 [template] // CHECK:STDOUT: %int_5.1: Core.IntLiteral = int_value 5 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] @@ -191,7 +191,7 @@ class Outer(T:! type) { // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class.1 @@ -506,9 +506,11 @@ class Outer(T:! type) { // CHECK:STDOUT: %D.1: %D.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %Outer.1 [symbolic] // CHECK:STDOUT: %Outer.val.1: %Outer.1 = struct_value () [symbolic] // CHECK:STDOUT: %Inner.type.2: type = generic_class_type @Inner, @Outer(%U) [symbolic] // CHECK:STDOUT: %Inner.generic.2: %Inner.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Outer.2 [symbolic] // CHECK:STDOUT: %Outer.val.2: %Outer.2 = struct_value () [symbolic] // CHECK:STDOUT: %A.type.2: type = fn_type @A, @Inner(%T, %T) [symbolic] // CHECK:STDOUT: %A.2: %A.type.2 = struct_value () [symbolic] @@ -518,7 +520,9 @@ class Outer(T:! type) { // CHECK:STDOUT: %C.2: %C.type.2 = struct_value () [symbolic] // CHECK:STDOUT: %D.type.2: type = fn_type @D, @Inner(%T, %T) [symbolic] // CHECK:STDOUT: %D.2: %D.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %Inner.2 [symbolic] // CHECK:STDOUT: %Inner.val.1: %Inner.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %Inner.1 [symbolic] // CHECK:STDOUT: %Inner.val.2: %Inner.1 = struct_value () [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -644,6 +648,7 @@ class Outer(T:! type) { // CHECK:STDOUT: %Outer.loc4_22.1: type = class_type @Outer, @Outer(%T) [symbolic = %Outer.loc4_22.1 (constants.%Outer.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @A.%Outer.loc4_22.1 (%Outer.1) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Outer.val: @A.%Outer.loc4_22.1 (%Outer.1) = struct_value () [symbolic = %Outer.val (constants.%Outer.val.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @A.%Outer.loc4_22.1 (%Outer.1) { @@ -660,6 +665,7 @@ class Outer(T:! type) { // CHECK:STDOUT: %Outer.loc7_22.1: type = class_type @Outer, @Outer(%U) [symbolic = %Outer.loc7_22.1 (constants.%Outer.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @B.%Outer.loc7_22.1 (%Outer.2) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %Outer.val: @B.%Outer.loc7_22.1 (%Outer.2) = struct_value () [symbolic = %Outer.val (constants.%Outer.val.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @B.%Outer.loc7_22.1 (%Outer.2) { @@ -678,6 +684,7 @@ class Outer(T:! type) { // CHECK:STDOUT: %Inner.loc10_22.1: type = class_type @Inner, @Inner(%T, %T) [symbolic = %Inner.loc10_22.1 (constants.%Inner.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @C.%Inner.loc10_22.1 (%Inner.2) [symbolic = %require_complete (constants.%require_complete.3)] // CHECK:STDOUT: %Inner.val: @C.%Inner.loc10_22.1 (%Inner.2) = struct_value () [symbolic = %Inner.val (constants.%Inner.val.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @C.%Inner.loc10_22.1 (%Inner.2) { @@ -697,6 +704,7 @@ class Outer(T:! type) { // CHECK:STDOUT: %Inner.loc13_22.1: type = class_type @Inner, @Inner(%T, %U) [symbolic = %Inner.loc13_22.1 (constants.%Inner.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @D.%Inner.loc13_22.1 (%Inner.1) [symbolic = %require_complete (constants.%require_complete.4)] // CHECK:STDOUT: %Inner.val: @D.%Inner.loc13_22.1 (%Inner.1) = struct_value () [symbolic = %Inner.val (constants.%Inner.val.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @D.%Inner.loc13_22.1 (%Inner.1) { diff --git a/toolchain/check/testdata/class/generic/field.carbon b/toolchain/check/testdata/class/generic/field.carbon index 3b861317ddf2..1ebf70f19f5b 100644 --- a/toolchain/check/testdata/class/generic/field.carbon +++ b/toolchain/check/testdata/class/generic/field.carbon @@ -32,6 +32,7 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class.1: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem.1: type = unbound_element_type %Class.1, %T [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] @@ -42,19 +43,23 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %Class.2: type = class_type @Class, @Class(%i32) [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %Class.elem.2: type = unbound_element_type %Class.2, %i32 [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.2 [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class.1 [symbolic] // CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic] // CHECK:STDOUT: %U.patt: type = symbolic_binding_pattern U, 0 [symbolic] // CHECK:STDOUT: %Class.3: type = class_type @Class, @Class(%U) [symbolic] // CHECK:STDOUT: %H.type: type = fn_type @H [template] // CHECK:STDOUT: %H: %H.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %U [symbolic] // CHECK:STDOUT: %Class.elem.3: type = unbound_element_type %Class.3, %U [symbolic] // CHECK:STDOUT: %struct_type.x.3: type = struct_type {.x: %U} [symbolic] -// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.3 [symbolic] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.x.3 [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %Class.3 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -147,6 +152,7 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %T.patt.loc11_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc11_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc11_13.2) [symbolic = %Class (constants.%Class.1)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class.1), @Class.%T.loc11_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @Class.%T.loc11_13.2 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x.1)] @@ -179,7 +185,9 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %Class.loc19_26.2: type = class_type @Class, @Class(%T.loc19_6.2) [symbolic = %Class.loc19_26.2 (constants.%Class.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc19: = require_complete_type @G.%Class.loc19_26.2 (%Class.1) [symbolic = %require_complete.loc19 (constants.%require_complete.2)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @G.%Class.loc19_26.2 (%Class.1), @G.%T.loc19_6.2 (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] +// CHECK:STDOUT: %require_complete.loc20: = require_complete_type @G.%T.loc19_6.2 (%T) [symbolic = %require_complete.loc20 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %c.param_patt: @G.%Class.loc19_26.2 (%Class.1)) -> @G.%T.loc19_6.2 (%T) { // CHECK:STDOUT: !entry: @@ -197,6 +205,8 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %Class.loc23_26.2: type = class_type @Class, @Class(%U.loc23_6.2) [symbolic = %Class.loc23_26.2 (constants.%Class.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc23_29: = require_complete_type @H.%U.loc23_6.2 (%U) [symbolic = %require_complete.loc23_29 (constants.%require_complete.3)] +// CHECK:STDOUT: %require_complete.loc23_17: = require_complete_type @H.%Class.loc23_26.2 (%Class.3) [symbolic = %require_complete.loc23_17 (constants.%require_complete.4)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @H.%Class.loc23_26.2 (%Class.3), @H.%U.loc23_6.2 (%U) [symbolic = %Class.elem (constants.%Class.elem.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%U.param_patt: type, %c.param_patt: @H.%Class.loc23_26.2 (%Class.3)) -> @H.%U.loc23_6.2 (%U) { @@ -214,6 +224,7 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %T.patt.loc11_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class.1 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.1 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.1 @@ -230,10 +241,11 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %T.patt.loc11_13.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Class => constants.%Class.2 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 -// CHECK:STDOUT: %complete_type.loc13_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc13_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class(@G.%T.loc19_6.2) { @@ -252,10 +264,11 @@ fn H(U:! type, c: Class(U)) -> U { // CHECK:STDOUT: %T.patt.loc11_13.2 => constants.%U // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.3 // CHECK:STDOUT: %Class => constants.%Class.3 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.3 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.3 -// CHECK:STDOUT: %complete_type.loc13_1.2 => constants.%complete_type.3 +// CHECK:STDOUT: %complete_type.loc13_1.2 => constants.%complete_type.4 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class(@H.%U.loc23_6.2) { diff --git a/toolchain/check/testdata/class/generic/import.carbon b/toolchain/check/testdata/class/generic/import.carbon index 2e3138016b2b..9424168a6c5a 100644 --- a/toolchain/check/testdata/class/generic/import.carbon +++ b/toolchain/check/testdata/class/generic/import.carbon @@ -102,7 +102,7 @@ class Class(U:! type) { // CHECK:STDOUT: %F.type.1: type = fn_type @F.1, @CompleteClass(%T) [symbolic] // CHECK:STDOUT: %F.1: %F.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.n [template] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -196,7 +196,7 @@ class Class(U:! type) { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%CompleteClass.1 @@ -260,6 +260,7 @@ class Class(U:! type) { // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete.7: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x [symbolic] @@ -344,6 +345,7 @@ class Class(U:! type) { // CHECK:STDOUT: %T.patt.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.1 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.1 (%T) [symbolic = %require_complete (constants.%require_complete.7)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.1) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.1 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %struct_type.x: type = struct_type {.x: @Class.%T.1 (%T)} [symbolic = %struct_type.x (constants.%struct_type.x)] diff --git a/toolchain/check/testdata/class/generic/init.carbon b/toolchain/check/testdata/class/generic/init.carbon index 41fa787d3027..bdfea5f7833f 100644 --- a/toolchain/check/testdata/class/generic/init.carbon +++ b/toolchain/check/testdata/class/generic/init.carbon @@ -50,11 +50,13 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class.1: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem.1: type = unbound_element_type %Class.1, %T [symbolic] // CHECK:STDOUT: %struct_type.k.1: type = struct_type {.k: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.k.1 [symbolic] // CHECK:STDOUT: %InitFromStructGeneric.type: type = fn_type @InitFromStructGeneric [template] // CHECK:STDOUT: %InitFromStructGeneric: %InitFromStructGeneric.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class.1 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -62,9 +64,10 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %InitFromStructSpecific.type: type = fn_type @InitFromStructSpecific [template] // CHECK:STDOUT: %InitFromStructSpecific: %InitFromStructSpecific.type = struct_value () [template] // CHECK:STDOUT: %Class.2: type = class_type @Class, @Class(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %Class.elem.2: type = unbound_element_type %Class.2, %i32 [template] // CHECK:STDOUT: %struct_type.k.2: type = struct_type {.k: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.k.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.k.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -133,6 +136,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc4_13.2) [symbolic = %Class (constants.%Class.1)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class.1), @Class.%T.loc4_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] // CHECK:STDOUT: %struct_type.k: type = struct_type {.k: @Class.%T.loc4_13.2 (%T)} [symbolic = %struct_type.k (constants.%struct_type.k.1)] @@ -155,7 +159,9 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc8_26.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_26.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc8: = require_complete_type @InitFromStructGeneric.%T.loc8_26.2 (%T) [symbolic = %require_complete.loc8 (constants.%require_complete.1)] // CHECK:STDOUT: %Class.loc9_17.2: type = class_type @Class, @Class(%T.loc8_26.2) [symbolic = %Class.loc9_17.2 (constants.%Class.1)] +// CHECK:STDOUT: %require_complete.loc9: = require_complete_type @InitFromStructGeneric.%Class.loc9_17.2 (%Class.1) [symbolic = %require_complete.loc9 (constants.%require_complete.2)] // CHECK:STDOUT: %struct_type.k: type = struct_type {.k: @InitFromStructGeneric.%T.loc8_26.2 (%T)} [symbolic = %struct_type.k (constants.%struct_type.k.1)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @InitFromStructGeneric.%Class.loc9_17.2 (%Class.1), @InitFromStructGeneric.%T.loc8_26.2 (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] // CHECK:STDOUT: @@ -210,6 +216,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class.1 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.1 // CHECK:STDOUT: %struct_type.k => constants.%struct_type.k.1 @@ -236,10 +243,11 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Class => constants.%Class.2 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.2 // CHECK:STDOUT: %struct_type.k => constants.%struct_type.k.2 -// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- adapt.carbon @@ -250,9 +258,11 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %Adapt.type: type = generic_class_type @Adapt [template] // CHECK:STDOUT: %Adapt.generic: %Adapt.type = struct_value () [template] // CHECK:STDOUT: %Adapt.1: type = class_type @Adapt, @Adapt(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %T [symbolic] // CHECK:STDOUT: %InitFromAdaptedGeneric.type: type = fn_type @InitFromAdaptedGeneric [template] // CHECK:STDOUT: %InitFromAdaptedGeneric: %InitFromAdaptedGeneric.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Adapt.1 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -329,6 +339,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Adapt.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %complete_type.loc6_1.2: = complete_type_witness @Adapt.%T.loc4_13.2 (%T) [symbolic = %complete_type.loc6_1.2 (constants.%complete_type.1)] // CHECK:STDOUT: // CHECK:STDOUT: class { @@ -347,7 +358,9 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc8_27.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_27.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc8: = require_complete_type @InitFromAdaptedGeneric.%T.loc8_27.2 (%T) [symbolic = %require_complete.loc8 (constants.%require_complete.1)] // CHECK:STDOUT: %Adapt.loc9_23.2: type = class_type @Adapt, @Adapt(%T.loc8_27.2) [symbolic = %Adapt.loc9_23.2 (constants.%Adapt.1)] +// CHECK:STDOUT: %require_complete.loc9: = require_complete_type @InitFromAdaptedGeneric.%Adapt.loc9_23.2 (%Adapt.1) [symbolic = %require_complete.loc9 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @InitFromAdaptedGeneric.%T.loc8_27.2 (%T)) -> @InitFromAdaptedGeneric.%T.loc8_27.2 (%T) { // CHECK:STDOUT: !entry: @@ -389,6 +402,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -407,6 +421,7 @@ fn InitFromAdaptedSpecific(x: i32) -> i32 { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %complete_type.loc6_1.2 => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_access.carbon b/toolchain/check/testdata/class/generic/member_access.carbon index 9df6e29ccaa7..c02c4e65b6e2 100644 --- a/toolchain/check/testdata/class/generic/member_access.carbon +++ b/toolchain/check/testdata/class/generic/member_access.carbon @@ -56,6 +56,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class.1: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem.1: type = unbound_element_type %Class.1, %T [symbolic] // CHECK:STDOUT: %Get.type.1: type = fn_type @Get, @Class(%T) [symbolic] // CHECK:STDOUT: %Get.1: %Get.type.1 = struct_value () [symbolic] @@ -65,6 +66,9 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %GetAddr.1: %GetAddr.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %struct_type.x.1: type = struct_type {.x: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.x.1 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class.1 [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %ptr.2 [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -72,19 +76,22 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.2: type = class_type @Class, @Class(%i32) [template] // CHECK:STDOUT: %DirectFieldAccess.type: type = fn_type @DirectFieldAccess [template] // CHECK:STDOUT: %DirectFieldAccess: %DirectFieldAccess.type = struct_value () [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: %Class.elem.2: type = unbound_element_type %Class.2, %i32 [template] // CHECK:STDOUT: %Get.type.2: type = fn_type @Get, @Class(%i32) [template] // CHECK:STDOUT: %Get.2: %Get.type.2 = struct_value () [template] // CHECK:STDOUT: %GetAddr.type.2: type = fn_type @GetAddr, @Class(%i32) [template] // CHECK:STDOUT: %GetAddr.2: %GetAddr.type.2 = struct_value () [template] // CHECK:STDOUT: %struct_type.x.2: type = struct_type {.x: %i32} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.x.2 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.x.2 [template] // CHECK:STDOUT: %MethodCall.type: type = fn_type @MethodCall [template] // CHECK:STDOUT: %MethodCall: %MethodCall.type = struct_value () [template] // CHECK:STDOUT: %ptr.5: type = ptr_type %Class.2 [template] // CHECK:STDOUT: %AddrMethodCall.type: type = fn_type @AddrMethodCall [template] // CHECK:STDOUT: %AddrMethodCall: %AddrMethodCall.type = struct_value () [template] // CHECK:STDOUT: %ptr.6: type = ptr_type %i32 [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %ptr.6 [template] +// CHECK:STDOUT: %complete_type.5: = complete_type_witness %ptr.5 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -182,6 +189,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %T.patt.loc2_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc2_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc2_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc2_13.2) [symbolic = %Class (constants.%Class.1)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class.1), @Class.%T.loc2_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] // CHECK:STDOUT: %Get.type: type = fn_type @Get, @Class(%T.loc2_13.2) [symbolic = %Get.type (constants.%Get.type.1)] @@ -241,7 +249,9 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc5_14: = require_complete_type @Get.%Class (%Class.1) [symbolic = %require_complete.loc5_14 (constants.%require_complete.2)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Get.%Class (%Class.1), @Get.%T (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] +// CHECK:STDOUT: %require_complete.loc5_42: = require_complete_type @Get.%T (%T) [symbolic = %require_complete.loc5_42 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @Get.%Class (%Class.1)]() -> @Get.%T (%T) { // CHECK:STDOUT: !entry: @@ -260,6 +270,9 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %ptr.loc7_38.1: type = ptr_type @GetAddr.%T (%T) [symbolic = %ptr.loc7_38.1 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_34: = require_complete_type @GetAddr.%ptr.loc7_38.1 (%ptr.2) [symbolic = %require_complete.loc7_34 (constants.%require_complete.3)] +// CHECK:STDOUT: %require_complete.loc7_23: = require_complete_type @GetAddr.%ptr.loc7_29.1 (%ptr.1) [symbolic = %require_complete.loc7_23 (constants.%require_complete.4)] +// CHECK:STDOUT: %require_complete.loc7_54: = require_complete_type @GetAddr.%Class (%Class.1) [symbolic = %require_complete.loc7_54 (constants.%require_complete.2)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @GetAddr.%Class (%Class.1), @GetAddr.%T (%T) [symbolic = %Class.elem (constants.%Class.elem.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[addr %self.param_patt: @GetAddr.%ptr.loc7_29.1 (%ptr.1)]() -> @GetAddr.%ptr.loc7_38.1 (%ptr.2) { @@ -317,6 +330,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %T.patt.loc2_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class.1 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.1 // CHECK:STDOUT: %Get.type => constants.%Get.type.1 @@ -359,6 +373,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %T.patt.loc2_13.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Class => constants.%Class.2 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.2 // CHECK:STDOUT: %Get.type => constants.%Get.type.2 @@ -366,7 +381,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %GetAddr.type => constants.%GetAddr.type.2 // CHECK:STDOUT: %GetAddr => constants.%GetAddr.2 // CHECK:STDOUT: %struct_type.x => constants.%struct_type.x.2 -// CHECK:STDOUT: %complete_type.loc8_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: %complete_type.loc8_1.2 => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Get(constants.%i32) { @@ -374,7 +389,9 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class => constants.%Class.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc5_14 => constants.%complete_type.3 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.2 +// CHECK:STDOUT: %require_complete.loc5_42 => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @GetAddr(constants.%i32) { @@ -384,6 +401,9 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %ptr.loc7_38.1 => constants.%ptr.6 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_34 => constants.%complete_type.4 +// CHECK:STDOUT: %require_complete.loc7_23 => constants.%complete_type.5 +// CHECK:STDOUT: %require_complete.loc7_54 => constants.%complete_type.3 // CHECK:STDOUT: %Class.elem => constants.%Class.elem.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -399,10 +419,13 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Make: %Make.type = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %Class [symbolic] // CHECK:STDOUT: %Class.val: %Class = struct_value () [symbolic] // CHECK:STDOUT: %StaticMemberFunctionCall.type: type = fn_type @StaticMemberFunctionCall [template] // CHECK:STDOUT: %StaticMemberFunctionCall: %StaticMemberFunctionCall.type = struct_value () [template] // CHECK:STDOUT: %Make.specific_fn: = specific_function %Make, @Make(%T) [symbolic] +// CHECK:STDOUT: %ImplicitAs.type.3: type = facet_type <@ImplicitAs, @ImplicitAs(%Class)> [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ImplicitAs.type.3 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -476,6 +499,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.loc5_23.1: type = class_type @Class, @Class(%T) [symbolic = %Class.loc5_23.1 (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Make.%Class.loc5_23.1 (%Class) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class.val: @Make.%Class.loc5_23.1 (%Class) = struct_value () [symbolic = %Class.val (constants.%Class.val)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @Make.%Class.loc5_23.1 (%Class) { @@ -493,9 +517,12 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.loc8_49.2: type = class_type @Class, @Class(%T.loc8_29.2) [symbolic = %Class.loc8_49.2 (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc15_18: = require_complete_type @StaticMemberFunctionCall.%Class.loc8_49.2 (%Class) [symbolic = %require_complete.loc15_18 (constants.%require_complete.1)] // CHECK:STDOUT: %Make.type: type = fn_type @Make, @Class(%T.loc8_29.2) [symbolic = %Make.type (constants.%Make.type)] // CHECK:STDOUT: %Make: @StaticMemberFunctionCall.%Make.type (%Make.type) = struct_value () [symbolic = %Make (constants.%Make)] // CHECK:STDOUT: %Make.specific_fn.loc15_18.2: = specific_function %Make, @Make(%T.loc8_29.2) [symbolic = %Make.specific_fn.loc15_18.2 (constants.%Make.specific_fn)] +// CHECK:STDOUT: %ImplicitAs.type: type = facet_type <@ImplicitAs, @ImplicitAs(%Class.loc8_49.2)> [symbolic = %ImplicitAs.type (constants.%ImplicitAs.type.3)] +// CHECK:STDOUT: %require_complete.loc15_25: = require_complete_type @StaticMemberFunctionCall.%ImplicitAs.type (%ImplicitAs.type.3) [symbolic = %require_complete.loc15_25 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> %return.param_patt: @StaticMemberFunctionCall.%Class.loc8_49.2 (%Class) { // CHECK:STDOUT: !entry: @@ -531,6 +558,7 @@ fn StaticMemberFunctionCall(T:! type) -> Class(T) { // CHECK:STDOUT: %Class.loc5_23.1 => constants.%Class // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class.val => constants.%Class.val // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/member_inline.carbon b/toolchain/check/testdata/class/generic/member_inline.carbon index 6cc17eac9b33..53b910784fe4 100644 --- a/toolchain/check/testdata/class/generic/member_inline.carbon +++ b/toolchain/check/testdata/class/generic/member_inline.carbon @@ -50,9 +50,11 @@ class C(T:! type) { // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G, @Class(%T) [symbolic] // CHECK:STDOUT: %G: %G.type = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: %T} [symbolic] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -86,6 +88,7 @@ class C(T:! type) { // CHECK:STDOUT: %F: @Class.%F.type (%F.type) = struct_value () [symbolic = %F (constants.%F)] // CHECK:STDOUT: %G.type: type = fn_type @G, @Class(%T.loc4_13.2) [symbolic = %G.type (constants.%G.type)] // CHECK:STDOUT: %G: @Class.%G.type (%G.type) = struct_value () [symbolic = %G (constants.%G)] +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc4_13.2) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.loc4_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: @Class.%T.loc4_13.2 (%T)} [symbolic = %struct_type.n (constants.%struct_type.n)] @@ -136,6 +139,7 @@ class C(T:! type) { // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%n.param_patt: @F.%T (%T)) -> @F.%T (%T) { // CHECK:STDOUT: !entry: @@ -149,7 +153,9 @@ class C(T:! type) { // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc9: = require_complete_type @G.%Class (%Class) [symbolic = %require_complete.loc9 (constants.%require_complete.2)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @G.%Class (%Class), @G.%T (%T) [symbolic = %Class.elem (constants.%Class.elem)] +// CHECK:STDOUT: %require_complete.loc10: = require_complete_type @G.%T (%T) [symbolic = %require_complete.loc10 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @G.%Class (%Class)]() -> @G.%T (%T) { // CHECK:STDOUT: !entry: @@ -170,6 +176,7 @@ class C(T:! type) { // CHECK:STDOUT: %F => constants.%F // CHECK:STDOUT: %G.type => constants.%G.type // CHECK:STDOUT: %G => constants.%G +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %Class.elem => constants.%Class.elem // CHECK:STDOUT: %struct_type.n => constants.%struct_type.n diff --git a/toolchain/check/testdata/class/generic/member_lookup.carbon b/toolchain/check/testdata/class/generic/member_lookup.carbon index ef262019aea9..aef2efd7d140 100644 --- a/toolchain/check/testdata/class/generic/member_lookup.carbon +++ b/toolchain/check/testdata/class/generic/member_lookup.carbon @@ -77,18 +77,21 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Base.type: type = generic_class_type @Base [template] // CHECK:STDOUT: %Base.generic: %Base.type = struct_value () [template] // CHECK:STDOUT: %Base.1: type = class_type @Base, @Base(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Base.elem.1: type = unbound_element_type %Base.1, %T [symbolic] // CHECK:STDOUT: %struct_type.b.1: type = struct_type {.b: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.b.1 [symbolic] // CHECK:STDOUT: %Derived.type: type = generic_class_type @Derived [template] // CHECK:STDOUT: %Derived.generic: %Derived.type = struct_value () [template] // CHECK:STDOUT: %Derived.1: type = class_type @Derived, @Derived(%T) [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Base.1 [symbolic] // CHECK:STDOUT: %Derived.elem.1: type = unbound_element_type %Derived.1, %Base.1 [symbolic] // CHECK:STDOUT: %Derived.elem.2: type = unbound_element_type %Derived.1, %T [symbolic] // CHECK:STDOUT: %struct_type.base.d.1: type = struct_type {.base: %Base.1, .d: %T} [symbolic] // CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.base.d.1 [symbolic] // CHECK:STDOUT: %AccessDerived.type: type = fn_type @AccessDerived [template] // CHECK:STDOUT: %AccessDerived: %AccessDerived.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %Derived.1 [symbolic] // CHECK:STDOUT: %AccessBase.type: type = fn_type @AccessBase [template] // CHECK:STDOUT: %AccessBase: %AccessBase.type = struct_value () [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] @@ -99,13 +102,14 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %AccessConcrete.type: type = fn_type @AccessConcrete [template] // CHECK:STDOUT: %AccessConcrete: %AccessConcrete.type = struct_value () [template] // CHECK:STDOUT: %Base.2: type = class_type @Base, @Base(%i32) [template] -// CHECK:STDOUT: %Derived.elem.3: type = unbound_element_type %Derived.2, %Base.2 [template] -// CHECK:STDOUT: %Derived.elem.4: type = unbound_element_type %Derived.2, %i32 [template] -// CHECK:STDOUT: %struct_type.base.d.3: type = struct_type {.base: %Base.2, .d: %i32} [template] -// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.base.d.3 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %i32 [template] // CHECK:STDOUT: %Base.elem.2: type = unbound_element_type %Base.2, %i32 [template] // CHECK:STDOUT: %struct_type.b.2: type = struct_type {.b: %i32} [template] // CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.b.2 [template] +// CHECK:STDOUT: %Derived.elem.3: type = unbound_element_type %Derived.2, %Base.2 [template] +// CHECK:STDOUT: %Derived.elem.4: type = unbound_element_type %Derived.2, %i32 [template] +// CHECK:STDOUT: %struct_type.base.d.3: type = struct_type {.base: %Base.2, .d: %i32} [template] +// CHECK:STDOUT: %complete_type.5: = complete_type_witness %struct_type.base.d.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -206,6 +210,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_17.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Base.%T.loc4_17.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T.loc4_17.2) [symbolic = %Base (constants.%Base.1)] // CHECK:STDOUT: %Base.elem: type = unbound_element_type @Base.%Base (%Base.1), @Base.%T.loc4_17.2 (%T) [symbolic = %Base.elem (constants.%Base.elem.1)] // CHECK:STDOUT: %struct_type.b: type = struct_type {.b: @Base.%T.loc4_17.2 (%T)} [symbolic = %struct_type.b (constants.%struct_type.b.1)] @@ -229,8 +234,10 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2: type = class_type @Base, @Base(%T.loc8_15.2) [symbolic = %Base.loc9_22.2 (constants.%Base.1)] +// CHECK:STDOUT: %require_complete.loc9: = require_complete_type @Derived.%Base.loc9_22.2 (%Base.1) [symbolic = %require_complete.loc9 (constants.%require_complete.2)] // CHECK:STDOUT: %Derived: type = class_type @Derived, @Derived(%T.loc8_15.2) [symbolic = %Derived (constants.%Derived.1)] // CHECK:STDOUT: %Derived.elem.loc9: type = unbound_element_type @Derived.%Derived (%Derived.1), @Derived.%Base.loc9_22.2 (%Base.1) [symbolic = %Derived.elem.loc9 (constants.%Derived.elem.1)] +// CHECK:STDOUT: %require_complete.loc10: = require_complete_type @Derived.%T.loc8_15.2 (%T) [symbolic = %require_complete.loc10 (constants.%require_complete.1)] // CHECK:STDOUT: %Derived.elem.loc10: type = unbound_element_type @Derived.%Derived (%Derived.1), @Derived.%T.loc8_15.2 (%T) [symbolic = %Derived.elem.loc10 (constants.%Derived.elem.2)] // CHECK:STDOUT: %struct_type.base.d: type = struct_type {.base: @Derived.%Base.loc9_22.2 (%Base.1), .d: @Derived.%T.loc8_15.2 (%T)} [symbolic = %struct_type.base.d (constants.%struct_type.base.d.1)] // CHECK:STDOUT: %complete_type.loc11_1.2: = complete_type_witness @Derived.%struct_type.base.d (%struct_type.base.d.1) [symbolic = %complete_type.loc11_1.2 (constants.%complete_type.2)] @@ -259,7 +266,9 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Derived.loc13_40.2: type = class_type @Derived, @Derived(%T.loc13_18.2) [symbolic = %Derived.loc13_40.2 (constants.%Derived.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc13: = require_complete_type @AccessDerived.%Derived.loc13_40.2 (%Derived.1) [symbolic = %require_complete.loc13 (constants.%require_complete.3)] // CHECK:STDOUT: %Derived.elem: type = unbound_element_type @AccessDerived.%Derived.loc13_40.2 (%Derived.1), @AccessDerived.%T.loc13_18.2 (%T) [symbolic = %Derived.elem (constants.%Derived.elem.2)] +// CHECK:STDOUT: %require_complete.loc14: = require_complete_type @AccessDerived.%T.loc13_18.2 (%T) [symbolic = %require_complete.loc14 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @AccessDerived.%Derived.loc13_40.2 (%Derived.1)) -> @AccessDerived.%T.loc13_18.2 (%T) { // CHECK:STDOUT: !entry: @@ -277,8 +286,11 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Derived.loc17_37.2: type = class_type @Derived, @Derived(%T.loc17_15.2) [symbolic = %Derived.loc17_37.2 (constants.%Derived.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc17: = require_complete_type @AccessBase.%Derived.loc17_37.2 (%Derived.1) [symbolic = %require_complete.loc17 (constants.%require_complete.3)] // CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T.loc17_15.2) [symbolic = %Base (constants.%Base.1)] +// CHECK:STDOUT: %require_complete.loc18_11: = require_complete_type @AccessBase.%Base (%Base.1) [symbolic = %require_complete.loc18_11 (constants.%require_complete.2)] // CHECK:STDOUT: %Base.elem: type = unbound_element_type @AccessBase.%Base (%Base.1), @AccessBase.%T.loc17_15.2 (%T) [symbolic = %Base.elem (constants.%Base.elem.1)] +// CHECK:STDOUT: %require_complete.loc18_13: = require_complete_type @AccessBase.%T.loc17_15.2 (%T) [symbolic = %require_complete.loc18_13 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @AccessBase.%Derived.loc17_37.2 (%Derived.1)) -> @AccessBase.%T.loc17_15.2 (%T) { // CHECK:STDOUT: !entry: @@ -308,6 +320,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Base => constants.%Base.1 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.1 // CHECK:STDOUT: %struct_type.b => constants.%struct_type.b.1 @@ -325,8 +338,10 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2 => constants.%Base.1 +// CHECK:STDOUT: %require_complete.loc9 => constants.%require_complete.2 // CHECK:STDOUT: %Derived => constants.%Derived.1 // CHECK:STDOUT: %Derived.elem.loc9 => constants.%Derived.elem.1 +// CHECK:STDOUT: %require_complete.loc10 => constants.%require_complete.1 // CHECK:STDOUT: %Derived.elem.loc10 => constants.%Derived.elem.2 // CHECK:STDOUT: %struct_type.base.d => constants.%struct_type.base.d.1 // CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.2 @@ -375,11 +390,13 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2 => constants.%Base.2 +// CHECK:STDOUT: %require_complete.loc9 => constants.%complete_type.4 // CHECK:STDOUT: %Derived => constants.%Derived.2 // CHECK:STDOUT: %Derived.elem.loc9 => constants.%Derived.elem.3 +// CHECK:STDOUT: %require_complete.loc10 => constants.%complete_type.3 // CHECK:STDOUT: %Derived.elem.loc10 => constants.%Derived.elem.4 // CHECK:STDOUT: %struct_type.base.d => constants.%struct_type.base.d.3 -// CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.3 +// CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.5 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Base(constants.%i32) { @@ -387,6 +404,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %Base => constants.%Base.2 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.2 // CHECK:STDOUT: %struct_type.b => constants.%struct_type.b.2 @@ -401,12 +419,14 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Base.type: type = generic_class_type @Base [template] // CHECK:STDOUT: %Base.generic: %Base.type = struct_value () [template] // CHECK:STDOUT: %Base.1: type = class_type @Base, @Base(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Base.elem.1: type = unbound_element_type %Base.1, %T [symbolic] // CHECK:STDOUT: %struct_type.b.1: type = struct_type {.b: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.b.1 [symbolic] // CHECK:STDOUT: %Derived.type: type = generic_class_type @Derived [template] // CHECK:STDOUT: %Derived.generic: %Derived.type = struct_value () [template] // CHECK:STDOUT: %Derived.1: type = class_type @Derived, @Derived(%T) [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Base.1 [symbolic] // CHECK:STDOUT: %Derived.elem.1: type = unbound_element_type %Derived.1, %Base.1 [symbolic] // CHECK:STDOUT: %Derived.elem.2: type = unbound_element_type %Derived.1, %T [symbolic] // CHECK:STDOUT: %struct_type.base.d.1: type = struct_type {.base: %Base.1, .d: %T} [symbolic] @@ -415,6 +435,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %AccessMissingBase: %AccessMissingBase.type = struct_value () [template] // CHECK:STDOUT: %AccessMissingDerived.type: type = fn_type @AccessMissingDerived [template] // CHECK:STDOUT: %AccessMissingDerived: %AccessMissingDerived.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %Derived.1 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -423,13 +444,14 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %AccessMissingConcrete.type: type = fn_type @AccessMissingConcrete [template] // CHECK:STDOUT: %AccessMissingConcrete: %AccessMissingConcrete.type = struct_value () [template] // CHECK:STDOUT: %Base.2: type = class_type @Base, @Base(%i32) [template] -// CHECK:STDOUT: %Derived.elem.3: type = unbound_element_type %Derived.2, %Base.2 [template] -// CHECK:STDOUT: %Derived.elem.4: type = unbound_element_type %Derived.2, %i32 [template] -// CHECK:STDOUT: %struct_type.base.d.3: type = struct_type {.base: %Base.2, .d: %i32} [template] -// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.base.d.3 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %i32 [template] // CHECK:STDOUT: %Base.elem.2: type = unbound_element_type %Base.2, %i32 [template] // CHECK:STDOUT: %struct_type.b.2: type = struct_type {.b: %i32} [template] // CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.b.2 [template] +// CHECK:STDOUT: %Derived.elem.3: type = unbound_element_type %Derived.2, %Base.2 [template] +// CHECK:STDOUT: %Derived.elem.4: type = unbound_element_type %Derived.2, %i32 [template] +// CHECK:STDOUT: %struct_type.base.d.3: type = struct_type {.base: %Base.2, .d: %i32} [template] +// CHECK:STDOUT: %complete_type.5: = complete_type_witness %struct_type.base.d.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -530,6 +552,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_17.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Base.%T.loc4_17.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T.loc4_17.2) [symbolic = %Base (constants.%Base.1)] // CHECK:STDOUT: %Base.elem: type = unbound_element_type @Base.%Base (%Base.1), @Base.%T.loc4_17.2 (%T) [symbolic = %Base.elem (constants.%Base.elem.1)] // CHECK:STDOUT: %struct_type.b: type = struct_type {.b: @Base.%T.loc4_17.2 (%T)} [symbolic = %struct_type.b (constants.%struct_type.b.1)] @@ -553,8 +576,10 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2: type = class_type @Base, @Base(%T.loc8_15.2) [symbolic = %Base.loc9_22.2 (constants.%Base.1)] +// CHECK:STDOUT: %require_complete.loc9: = require_complete_type @Derived.%Base.loc9_22.2 (%Base.1) [symbolic = %require_complete.loc9 (constants.%require_complete.2)] // CHECK:STDOUT: %Derived: type = class_type @Derived, @Derived(%T.loc8_15.2) [symbolic = %Derived (constants.%Derived.1)] // CHECK:STDOUT: %Derived.elem.loc9: type = unbound_element_type @Derived.%Derived (%Derived.1), @Derived.%Base.loc9_22.2 (%Base.1) [symbolic = %Derived.elem.loc9 (constants.%Derived.elem.1)] +// CHECK:STDOUT: %require_complete.loc10: = require_complete_type @Derived.%T.loc8_15.2 (%T) [symbolic = %require_complete.loc10 (constants.%require_complete.1)] // CHECK:STDOUT: %Derived.elem.loc10: type = unbound_element_type @Derived.%Derived (%Derived.1), @Derived.%T.loc8_15.2 (%T) [symbolic = %Derived.elem.loc10 (constants.%Derived.elem.2)] // CHECK:STDOUT: %struct_type.base.d: type = struct_type {.base: @Derived.%Base.loc9_22.2 (%Base.1), .d: @Derived.%T.loc8_15.2 (%T)} [symbolic = %struct_type.base.d (constants.%struct_type.base.d.1)] // CHECK:STDOUT: %complete_type.loc11_1.2: = complete_type_witness @Derived.%struct_type.base.d (%struct_type.base.d.1) [symbolic = %complete_type.loc11_1.2 (constants.%complete_type.2)] @@ -583,6 +608,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Base.loc13_41.2: type = class_type @Base, @Base(%T.loc13_22.2) [symbolic = %Base.loc13_41.2 (constants.%Base.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @AccessMissingBase.%Base.loc13_41.2 (%Base.1) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @AccessMissingBase.%Base.loc13_41.2 (%Base.1)) -> @AccessMissingBase.%T.loc13_22.2 (%T) { // CHECK:STDOUT: !entry: @@ -598,6 +624,9 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Derived.loc21_47.2: type = class_type @Derived, @Derived(%T.loc21_25.2) [symbolic = %Derived.loc21_47.2 (constants.%Derived.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc21: = require_complete_type @AccessMissingDerived.%Derived.loc21_47.2 (%Derived.1) [symbolic = %require_complete.loc21 (constants.%require_complete.3)] +// CHECK:STDOUT: %Base: type = class_type @Base, @Base(%T.loc21_25.2) [symbolic = %Base (constants.%Base.1)] +// CHECK:STDOUT: %require_complete.loc26: = require_complete_type @AccessMissingDerived.%Base (%Base.1) [symbolic = %require_complete.loc26 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @AccessMissingDerived.%Derived.loc21_47.2 (%Derived.1)) -> @AccessMissingDerived.%T.loc21_25.2 (%T) { // CHECK:STDOUT: !entry: @@ -619,6 +648,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Base => constants.%Base.1 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.1 // CHECK:STDOUT: %struct_type.b => constants.%struct_type.b.1 @@ -636,8 +666,10 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2 => constants.%Base.1 +// CHECK:STDOUT: %require_complete.loc9 => constants.%require_complete.2 // CHECK:STDOUT: %Derived => constants.%Derived.1 // CHECK:STDOUT: %Derived.elem.loc9 => constants.%Derived.elem.1 +// CHECK:STDOUT: %require_complete.loc10 => constants.%require_complete.1 // CHECK:STDOUT: %Derived.elem.loc10 => constants.%Derived.elem.2 // CHECK:STDOUT: %struct_type.base.d => constants.%struct_type.base.d.1 // CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.2 @@ -675,17 +707,24 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %Derived.loc21_47.2 => constants.%Derived.1 // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: specific @Base(@AccessMissingDerived.%T.loc21_25.2) { +// CHECK:STDOUT: %T.loc4_17.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: specific @Derived(constants.%i32) { // CHECK:STDOUT: %T.loc8_15.2 => constants.%i32 // CHECK:STDOUT: %T.patt.loc8_15.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Base.loc9_22.2 => constants.%Base.2 +// CHECK:STDOUT: %require_complete.loc9 => constants.%complete_type.4 // CHECK:STDOUT: %Derived => constants.%Derived.2 // CHECK:STDOUT: %Derived.elem.loc9 => constants.%Derived.elem.3 +// CHECK:STDOUT: %require_complete.loc10 => constants.%complete_type.3 // CHECK:STDOUT: %Derived.elem.loc10 => constants.%Derived.elem.4 // CHECK:STDOUT: %struct_type.base.d => constants.%struct_type.base.d.3 -// CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.3 +// CHECK:STDOUT: %complete_type.loc11_1.2 => constants.%complete_type.5 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Base(constants.%i32) { @@ -693,6 +732,7 @@ fn AccessMissingConcrete(x: Derived(i32)) -> i32 { // CHECK:STDOUT: %T.patt.loc4_17.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %Base => constants.%Base.2 // CHECK:STDOUT: %Base.elem => constants.%Base.elem.2 // CHECK:STDOUT: %struct_type.b => constants.%struct_type.b.2 diff --git a/toolchain/check/testdata/class/generic/member_out_of_line.carbon b/toolchain/check/testdata/class/generic/member_out_of_line.carbon index b0c1fd4862d5..f85a1169457a 100644 --- a/toolchain/check/testdata/class/generic/member_out_of_line.carbon +++ b/toolchain/check/testdata/class/generic/member_out_of_line.carbon @@ -117,9 +117,11 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G, @Class(%T) [symbolic] // CHECK:STDOUT: %G: %G.type = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: %T} [symbolic] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -184,6 +186,7 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %F: @Class.%F.type (%F.type) = struct_value () [symbolic = %F (constants.%F)] // CHECK:STDOUT: %G.type: type = fn_type @G, @Class(%T.loc4_13.2) [symbolic = %G.type (constants.%G.type)] // CHECK:STDOUT: %G: @Class.%G.type (%G.type) = struct_value () [symbolic = %G (constants.%G)] +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc4_13.2) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.loc4_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: @Class.%T.loc4_13.2 (%T)} [symbolic = %struct_type.n (constants.%struct_type.n)] @@ -234,6 +237,7 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %T.loc5: type = bind_symbolic_name T, 0 [symbolic = %T.loc5 (constants.%T)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T.loc5 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%n.param_patt: %T) -> %T { // CHECK:STDOUT: !entry: @@ -247,7 +251,9 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc6) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc14: = require_complete_type @G.%Class (%Class) [symbolic = %require_complete.loc14 (constants.%require_complete.2)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @G.%Class (%Class), @G.%T.loc6 (%T) [symbolic = %Class.elem (constants.%Class.elem)] +// CHECK:STDOUT: %require_complete.loc15: = require_complete_type @G.%T.loc6 (%T) [symbolic = %require_complete.loc15 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: %Class]() -> %T { // CHECK:STDOUT: !entry: @@ -268,6 +274,7 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %F => constants.%F // CHECK:STDOUT: %G.type => constants.%G.type // CHECK:STDOUT: %G => constants.%G +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %Class.elem => constants.%Class.elem // CHECK:STDOUT: %struct_type.n => constants.%struct_type.n @@ -310,6 +317,8 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %B [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -418,6 +427,8 @@ fn Generic(T:! ()).WrongType() {} // CHECK:STDOUT: %B: type = class_type @B, @B(%T.loc6, %N.loc6) [symbolic = %B (constants.%B)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc10_31: = require_complete_type @F.%B (%B) [symbolic = %require_complete.loc10_31 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc10_40: = require_complete_type @F.%T.loc6 (%T) [symbolic = %require_complete.loc10_40 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: %B](%a.param_patt: %T) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/class/generic/method_deduce.carbon b/toolchain/check/testdata/class/generic/method_deduce.carbon index 3eb855cd8f70..d87b35d058f8 100644 --- a/toolchain/check/testdata/class/generic/method_deduce.carbon +++ b/toolchain/check/testdata/class/generic/method_deduce.carbon @@ -29,7 +29,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: constants { // CHECK:STDOUT: %A: type = class_type @A [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %B: type = class_type @B [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] @@ -44,7 +44,10 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %Get.1: %Get.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %GetNoDeduce.type.1: type = fn_type @GetNoDeduce, @Class(%T) [symbolic] // CHECK:STDOUT: %GetNoDeduce.1: %GetNoDeduce.type.1 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %tuple.type.2 [symbolic] // CHECK:STDOUT: %Get.specific_fn.1: = specific_function %Get.1, @Get(%T, %U) [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %U [symbolic] // CHECK:STDOUT: %GetNoDeduce.specific_fn.1: = specific_function %GetNoDeduce.1, @GetNoDeduce(%T, %U) [symbolic] // CHECK:STDOUT: %Class.2: type = class_type @Class, @Class(%A) [template] // CHECK:STDOUT: %tuple.type.3: type = tuple_type (%A, %B) [template] @@ -59,6 +62,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %CallGenericMethodWithNonDeducedParam: %CallGenericMethodWithNonDeducedParam.type = struct_value () [template] // CHECK:STDOUT: %GetNoDeduce.specific_fn.2: = specific_function %GetNoDeduce.2, @GetNoDeduce(%A, %B) [template] // CHECK:STDOUT: %A.val: %A = struct_value () [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %tuple.type.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -126,7 +130,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @A { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -134,7 +138,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @B { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%B @@ -187,7 +191,7 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %return.param: ref @GetNoDeduce.%tuple.type (%tuple.type.2) = out_param runtime_param1 // CHECK:STDOUT: %return: ref @GetNoDeduce.%tuple.type (%tuple.type.2) = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class.1 @@ -204,9 +208,12 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type: type = tuple_type (@Get.%T (%T), @Get.%U.loc15_10.1 (%U)) [symbolic = %tuple.type (constants.%tuple.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc15_20: = require_complete_type @Get.%tuple.type (%tuple.type.2) [symbolic = %require_complete.loc15_20 (constants.%require_complete.1)] // CHECK:STDOUT: %Get.type: type = fn_type @Get, @Class(%T) [symbolic = %Get.type (constants.%Get.type.1)] // CHECK:STDOUT: %Get: @Get.%Get.type (%Get.type.1) = struct_value () [symbolic = %Get (constants.%Get.1)] // CHECK:STDOUT: %Get.specific_fn.loc15_39.2: = specific_function %Get, @Get(%T, %U.loc15_10.1) [symbolic = %Get.specific_fn.loc15_39.2 (constants.%Get.specific_fn.1)] +// CHECK:STDOUT: %require_complete.loc15_44.1: = require_complete_type @Get.%T (%T) [symbolic = %require_complete.loc15_44.1 (constants.%require_complete.2)] +// CHECK:STDOUT: %require_complete.loc15_44.2: = require_complete_type @Get.%U.loc15_10.1 (%U) [symbolic = %require_complete.loc15_44.2 (constants.%require_complete.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%U.param_patt: type) -> %return.param_patt: @Get.%tuple.type (%tuple.type.2) { // CHECK:STDOUT: !entry: @@ -238,9 +245,12 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type: type = tuple_type (@GetNoDeduce.%T (%T), @GetNoDeduce.%U.loc16_24.1 (%U)) [symbolic = %tuple.type (constants.%tuple.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc16_19: = require_complete_type @GetNoDeduce.%T (%T) [symbolic = %require_complete.loc16_19 (constants.%require_complete.2)] // CHECK:STDOUT: %GetNoDeduce.type: type = fn_type @GetNoDeduce, @Class(%T) [symbolic = %GetNoDeduce.type (constants.%GetNoDeduce.type.1)] // CHECK:STDOUT: %GetNoDeduce: @GetNoDeduce.%GetNoDeduce.type (%GetNoDeduce.type.1) = struct_value () [symbolic = %GetNoDeduce (constants.%GetNoDeduce.1)] // CHECK:STDOUT: %GetNoDeduce.specific_fn.loc16_53.2: = specific_function %GetNoDeduce, @GetNoDeduce(%T, %U.loc16_24.1) [symbolic = %GetNoDeduce.specific_fn.loc16_53.2 (constants.%GetNoDeduce.specific_fn.1)] +// CHECK:STDOUT: %require_complete.loc16_70: = require_complete_type @GetNoDeduce.%tuple.type (%tuple.type.2) [symbolic = %require_complete.loc16_70 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc16_69: = require_complete_type @GetNoDeduce.%U.loc16_24.1 (%U) [symbolic = %require_complete.loc16_69 (constants.%require_complete.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%x.param_patt: @GetNoDeduce.%T (%T), %U.param_patt: type) -> %return.param_patt: @GetNoDeduce.%tuple.type (%tuple.type.2) { // CHECK:STDOUT: !entry: @@ -314,9 +324,12 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc15_20 => constants.%require_complete.1 // CHECK:STDOUT: %Get.type => constants.%Get.type.1 // CHECK:STDOUT: %Get => constants.%Get.1 // CHECK:STDOUT: %Get.specific_fn.loc15_39.2 => constants.%Get.specific_fn.1 +// CHECK:STDOUT: %require_complete.loc15_44.1 => constants.%require_complete.2 +// CHECK:STDOUT: %require_complete.loc15_44.2 => constants.%require_complete.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @GetNoDeduce(constants.%T, constants.%U) { @@ -326,9 +339,12 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc16_19 => constants.%require_complete.2 // CHECK:STDOUT: %GetNoDeduce.type => constants.%GetNoDeduce.type.1 // CHECK:STDOUT: %GetNoDeduce => constants.%GetNoDeduce.1 // CHECK:STDOUT: %GetNoDeduce.specific_fn.loc16_53.2 => constants.%GetNoDeduce.specific_fn.1 +// CHECK:STDOUT: %require_complete.loc16_70 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc16_69 => constants.%require_complete.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Class(%T.loc14_13.2) { @@ -378,9 +394,12 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc15_20 => constants.%complete_type.2 // CHECK:STDOUT: %Get.type => constants.%Get.type.2 // CHECK:STDOUT: %Get => constants.%Get.2 // CHECK:STDOUT: %Get.specific_fn.loc15_39.2 => constants.%Get.specific_fn.2 +// CHECK:STDOUT: %require_complete.loc15_44.1 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc15_44.2 => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @GetNoDeduce(constants.%A, constants.%B) { @@ -390,8 +409,11 @@ fn CallGenericMethodWithNonDeducedParam(c: Class(A)) -> (A, B) { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc16_19 => constants.%complete_type.1 // CHECK:STDOUT: %GetNoDeduce.type => constants.%GetNoDeduce.type.2 // CHECK:STDOUT: %GetNoDeduce => constants.%GetNoDeduce.2 // CHECK:STDOUT: %GetNoDeduce.specific_fn.loc16_53.2 => constants.%GetNoDeduce.specific_fn.2 +// CHECK:STDOUT: %require_complete.loc16_70 => constants.%complete_type.2 +// CHECK:STDOUT: %require_complete.loc16_69 => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/self.carbon b/toolchain/check/testdata/class/generic/self.carbon index 17f246435ea6..b6e2f746f75e 100644 --- a/toolchain/check/testdata/class/generic/self.carbon +++ b/toolchain/check/testdata/class/generic/self.carbon @@ -35,6 +35,7 @@ class Class(T:! type) { // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %Class [symbolic] // CHECK:STDOUT: %Class.val: %Class = struct_value () [symbolic] // CHECK:STDOUT: %MakeSelf.specific_fn: = specific_function %MakeSelf, @MakeSelf(%T) [symbolic] // CHECK:STDOUT: %MakeClass.specific_fn: = specific_function %MakeClass, @MakeClass(%T) [symbolic] @@ -111,6 +112,7 @@ class Class(T:! type) { // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @MakeSelf.%Class (%Class) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Class.val: @MakeSelf.%Class (%Class) = struct_value () [symbolic = %Class.val (constants.%Class.val)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @MakeSelf.%Class (%Class) { @@ -127,6 +129,7 @@ class Class(T:! type) { // CHECK:STDOUT: %Class.loc15_28.1: type = class_type @Class, @Class(%T) [symbolic = %Class.loc15_28.1 (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @MakeClass.%Class.loc15_28.1 (%Class) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Class.val: @MakeClass.%Class.loc15_28.1 (%Class) = struct_value () [symbolic = %Class.val (constants.%Class.val)] // CHECK:STDOUT: // CHECK:STDOUT: fn() -> %return.param_patt: @MakeClass.%Class.loc15_28.1 (%Class) { @@ -142,6 +145,7 @@ class Class(T:! type) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: %Class.loc17_19.2: type = class_type @Class, @Class(%T) [symbolic = %Class.loc17_19.2 (constants.%Class)] +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%Class.loc17_19.2 (%Class) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %MakeSelf.type: type = fn_type @MakeSelf, @Class(%T) [symbolic = %MakeSelf.type (constants.%MakeSelf.type)] // CHECK:STDOUT: %MakeSelf: @F.%MakeSelf.type (%MakeSelf.type) = struct_value () [symbolic = %MakeSelf (constants.%MakeSelf)] // CHECK:STDOUT: %MakeSelf.specific_fn.loc17_23.2: = specific_function %MakeSelf, @MakeSelf(%T) [symbolic = %MakeSelf.specific_fn.loc17_23.2 (constants.%MakeSelf.specific_fn)] @@ -199,6 +203,7 @@ class Class(T:! type) { // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %Class.val => constants.%Class.val // CHECK:STDOUT: } // CHECK:STDOUT: @@ -212,6 +217,7 @@ class Class(T:! type) { // CHECK:STDOUT: %Class.loc15_28.1 => constants.%Class // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %Class.val => constants.%Class.val // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/generic/stringify.carbon b/toolchain/check/testdata/class/generic/stringify.carbon index 305f11bf08e2..64720dd14b1c 100644 --- a/toolchain/check/testdata/class/generic/stringify.carbon +++ b/toolchain/check/testdata/class/generic/stringify.carbon @@ -293,7 +293,7 @@ var v: C(123) = (); // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%N.1) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_123.1: Core.IntLiteral = int_value 123 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -352,7 +352,7 @@ var v: C(123) = (); // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C.1 diff --git a/toolchain/check/testdata/class/generic_method.carbon b/toolchain/check/testdata/class/generic_method.carbon index b008b066f3db..a35b6529fe35 100644 --- a/toolchain/check/testdata/class/generic_method.carbon +++ b/toolchain/check/testdata/class/generic_method.carbon @@ -23,11 +23,13 @@ fn Class(T:! type).F[self: Self](n: T) {} // CHECK:STDOUT: %Class.type: type = generic_class_type @Class [template] // CHECK:STDOUT: %Class.generic: %Class.type = struct_value () [template] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F, @Class(%T) [symbolic] // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %struct_type.a: type = struct_type {.a: %T} [symbolic] // CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Class [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -73,6 +75,7 @@ fn Class(T:! type).F[self: Self](n: T) {} // CHECK:STDOUT: %T.patt.loc11_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Class.%T.loc11_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc11_13.2) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: %Class.elem: type = unbound_element_type @Class.%Class (%Class), @Class.%T.loc11_13.2 (%T) [symbolic = %Class.elem (constants.%Class.elem)] // CHECK:STDOUT: %F.type: type = fn_type @F, @Class(%T.loc11_13.2) [symbolic = %F.type (constants.%F.type)] @@ -112,6 +115,8 @@ fn Class(T:! type).F[self: Self](n: T) {} // CHECK:STDOUT: %Class: type = class_type @Class, @Class(%T.loc13) [symbolic = %Class (constants.%Class)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc16_26: = require_complete_type @F.%Class (%Class) [symbolic = %require_complete.loc16_26 (constants.%require_complete.2)] +// CHECK:STDOUT: %require_complete.loc16_35: = require_complete_type @F.%T.loc13 (%T) [symbolic = %require_complete.loc16_35 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: %Class](%n.param_patt: %T) { // CHECK:STDOUT: !entry: @@ -124,6 +129,7 @@ fn Class(T:! type).F[self: Self](n: T) {} // CHECK:STDOUT: %T.patt.loc11_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Class => constants.%Class // CHECK:STDOUT: %Class.elem => constants.%Class.elem // CHECK:STDOUT: %F.type => constants.%F.type diff --git a/toolchain/check/testdata/class/import.carbon b/toolchain/check/testdata/class/import.carbon index 2707ce3dc2a2..2dc900296825 100644 --- a/toolchain/check/testdata/class/import.carbon +++ b/toolchain/check/testdata/class/import.carbon @@ -330,5 +330,5 @@ fn Run() { // CHECK:STDOUT: // CHECK:STDOUT: fn @F[%self.param_patt: %ForwardDeclared.1]() [from "a.carbon"]; // CHECK:STDOUT: -// CHECK:STDOUT: fn @G[addr .inst401: %ptr.3]() [from "a.carbon"]; +// CHECK:STDOUT: fn @G[addr .inst419: %ptr.3]() [from "a.carbon"]; // CHECK:STDOUT: diff --git a/toolchain/check/testdata/class/inheritance_access.carbon b/toolchain/check/testdata/class/inheritance_access.carbon index 084611886045..8e5b9fcaa438 100644 --- a/toolchain/check/testdata/class/inheritance_access.carbon +++ b/toolchain/check/testdata/class/inheritance_access.carbon @@ -490,7 +490,7 @@ class B { // CHECK:STDOUT: %SomeProtectedFunction.type: type = fn_type @SomeProtectedFunction [template] // CHECK:STDOUT: %SomeProtectedFunction: %SomeProtectedFunction.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %B: type = class_type @B [template] // CHECK:STDOUT: %B.elem: type = unbound_element_type %B, %A [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] @@ -498,7 +498,7 @@ class B { // CHECK:STDOUT: %H.type: type = fn_type @H [template] // CHECK:STDOUT: %H: %H.type = struct_value () [template] // CHECK:STDOUT: %struct_type.base: type = struct_type {.base: %A} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.base [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.base [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -545,7 +545,7 @@ class B { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -579,7 +579,7 @@ class B { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.base [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.base [template = constants.%complete_type.4] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%B @@ -974,7 +974,7 @@ class B { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_5.2: %i32 = int_value 5 [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %Internal: type = class_type @Internal [template] // CHECK:STDOUT: %B: type = class_type @B [template] // CHECK:STDOUT: %B.elem: type = unbound_element_type %B, %Internal [template] @@ -983,7 +983,7 @@ class B { // CHECK:STDOUT: %SomeFunc.type: type = fn_type @SomeFunc [template] // CHECK:STDOUT: %SomeFunc: %SomeFunc.type = struct_value () [template] // CHECK:STDOUT: %struct_type.internal.1: type = struct_type {.internal: %Internal} [template] -// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.internal.1 [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.internal.1 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -1033,7 +1033,7 @@ class B { // CHECK:STDOUT: %.loc6_45.1: %i32 = value_of_initializer %int.convert_checked.loc6 [template = constants.%int_5.2] // CHECK:STDOUT: %.loc6_45.2: %i32 = converted %int_5.loc6, %.loc6_45.1 [template = constants.%int_5.2] // CHECK:STDOUT: %SOME_PRIVATE_CONSTANT: %i32 = bind_name SOME_PRIVATE_CONSTANT, %.loc6_45.2 -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -1055,7 +1055,7 @@ class B { // CHECK:STDOUT: %.loc10_43.1: %i32 = value_of_initializer %int.convert_checked [template = constants.%int_5.2] // CHECK:STDOUT: %.loc10_43.2: %i32 = converted %int_5, %.loc10_43.1 [template = constants.%int_5.2] // CHECK:STDOUT: %INTERNAL_CONSTANT: %i32 = bind_name INTERNAL_CONSTANT, %.loc10_43.2 -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Internal @@ -1093,7 +1093,7 @@ class B { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param1 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.internal.1 [template = constants.%complete_type.2] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.internal.1 [template = constants.%complete_type.4] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%B diff --git a/toolchain/check/testdata/class/init_as.carbon b/toolchain/check/testdata/class/init_as.carbon index 5852c378d631..ff35a2ba27e7 100644 --- a/toolchain/check/testdata/class/init_as.carbon +++ b/toolchain/check/testdata/class/init_as.carbon @@ -27,7 +27,7 @@ fn F() -> i32 { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -87,7 +87,7 @@ fn F() -> i32 { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %Class.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/method.carbon b/toolchain/check/testdata/class/method.carbon index 77ecdbc83bc5..44cac1cd7185 100644 --- a/toolchain/check/testdata/class/method.carbon +++ b/toolchain/check/testdata/class/method.carbon @@ -73,7 +73,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %Class.elem: type = unbound_element_type %Class, %i32 [template] // CHECK:STDOUT: %struct_type.k.1: type = struct_type {.k: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.k.1 [template] // CHECK:STDOUT: %Call.type: type = fn_type @Call [template] // CHECK:STDOUT: %Call: %Call.type = struct_value () [template] // CHECK:STDOUT: %CallAlias.type: type = fn_type @CallAlias [template] @@ -307,7 +307,7 @@ fn CallGOnInitializingExpr() -> i32 { // CHECK:STDOUT: %.loc17_10.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32] // CHECK:STDOUT: %.loc17_10.2: type = converted %int.make_type_signed, %.loc17_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc17_8: %Class.elem = field_decl k, element0 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.k.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/reorder.carbon b/toolchain/check/testdata/class/reorder.carbon index 3beded487809..63c4e2b18a2d 100644 --- a/toolchain/check/testdata/class/reorder.carbon +++ b/toolchain/check/testdata/class/reorder.carbon @@ -31,7 +31,7 @@ class Class { // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -83,7 +83,7 @@ class Class { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/scope.carbon b/toolchain/check/testdata/class/scope.carbon index 2bd018d57a6a..16f7fe3fceea 100644 --- a/toolchain/check/testdata/class/scope.carbon +++ b/toolchain/check/testdata/class/scope.carbon @@ -40,7 +40,7 @@ fn Run() { // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -114,7 +114,7 @@ fn Run() { // CHECK:STDOUT: %return.param: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return: ref %i32 = return_slot %return.param // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class diff --git a/toolchain/check/testdata/class/syntactic_merge_literal.carbon b/toolchain/check/testdata/class/syntactic_merge_literal.carbon index 8c6c62f434e1..af6ad9aa7285 100644 --- a/toolchain/check/testdata/class/syntactic_merge_literal.carbon +++ b/toolchain/check/testdata/class/syntactic_merge_literal.carbon @@ -41,7 +41,7 @@ class D(b:! C(1_000)) {} // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%a) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1000.1: Core.IntLiteral = int_value 1000 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -126,7 +126,7 @@ class D(b:! C(1_000)) {} // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C.1 @@ -141,7 +141,7 @@ class D(b:! C(1_000)) {} // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%D @@ -177,7 +177,7 @@ class D(b:! C(1_000)) {} // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%a) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1000.1: Core.IntLiteral = int_value 1000 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -264,7 +264,7 @@ class D(b:! C(1_000)) {} // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C.1 @@ -286,7 +286,7 @@ class D(b:! C(1_000)) {} // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%.1 diff --git a/toolchain/check/testdata/class/virtual_modifiers.carbon b/toolchain/check/testdata/class/virtual_modifiers.carbon index 09a12635346a..e68d6da24948 100644 --- a/toolchain/check/testdata/class/virtual_modifiers.carbon +++ b/toolchain/check/testdata/class/virtual_modifiers.carbon @@ -508,7 +508,7 @@ class Derived { // CHECK:STDOUT: %F.1: %F.type.1 = struct_value () [template] // CHECK:STDOUT: %ptr.1: type = ptr_type [template] // CHECK:STDOUT: %struct_type.vptr.m1.m2: type = struct_type {.: %ptr.1, .m1: %i32, .m2: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.vptr.m1.m2 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.vptr.m1.m2 [template] // CHECK:STDOUT: %F.type.2: type = fn_type @F.2 [template] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [template] // CHECK:STDOUT: %int_3.1: Core.IntLiteral = int_value 3 [template] @@ -563,7 +563,7 @@ class Derived { // CHECK:STDOUT: %.loc6_11.2: type = converted %int.make_type_signed.loc6, %.loc6_11.1 [template = constants.%i32] // CHECK:STDOUT: %.loc6_9: %Base.elem = field_decl m2, element2 [template] // CHECK:STDOUT: %F.decl: %F.type.1 = fn_decl @F.1 [template = constants.%F.1] {} {} -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.vptr.m1.m2 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.vptr.m1.m2 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Base diff --git a/toolchain/check/testdata/deduce/array.carbon b/toolchain/check/testdata/deduce/array.carbon index dad4826a7518..63ae9cf40346 100644 --- a/toolchain/check/testdata/deduce/array.carbon +++ b/toolchain/check/testdata/deduce/array.carbon @@ -102,13 +102,15 @@ fn G() -> C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] // CHECK:STDOUT: %array_type.1: type = array_type %int_3, %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %array_type.1 [symbolic] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -130,6 +132,7 @@ fn G() -> C { // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] // CHECK:STDOUT: %array: %array_type.2 = tuple_value (%C.val, %C.val, %C.val) [template] // CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%C) [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %array_type.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -180,7 +183,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -193,6 +196,8 @@ fn G() -> C { // CHECK:STDOUT: %array_type.loc6_24.2: type = array_type constants.%int_3, @F.%T.loc6_6.2 (%T) [symbolic = %array_type.loc6_24.2 (constants.%array_type.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_27: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_27 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%array_type.loc6_24.2 (%array_type.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%a.param_patt: @F.%array_type.loc6_24.2 (%array_type.1)) -> @F.%T.loc6_6.2 (%T) { // CHECK:STDOUT: !entry: @@ -262,6 +267,8 @@ fn G() -> C { // CHECK:STDOUT: %array_type.loc6_24.2 => constants.%array_type.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_27 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.4 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_bound_only.carbon @@ -269,7 +276,7 @@ fn G() -> C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -358,7 +365,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -425,7 +432,7 @@ fn G() -> C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] @@ -517,7 +524,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -582,13 +589,15 @@ fn G() -> C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %int_2: Core.IntLiteral = int_value 2 [template] // CHECK:STDOUT: %array_type.1: type = array_type %int_2, %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %array_type.1 [symbolic] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -611,6 +620,7 @@ fn G() -> C { // CHECK:STDOUT: %array: %array_type.2 = tuple_value (%C.val, %C.val, %C.val) [template] // CHECK:STDOUT: %array_type.3: type = array_type %int_2, %C [template] // CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%C) [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %array_type.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -661,7 +671,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -674,6 +684,8 @@ fn G() -> C { // CHECK:STDOUT: %array_type.loc6_24.2: type = array_type constants.%int_2, @F.%T.loc6_6.2 (%T) [symbolic = %array_type.loc6_24.2 (constants.%array_type.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_27: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_27 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%array_type.loc6_24.2 (%array_type.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%a.param_patt: @F.%array_type.loc6_24.2 (%array_type.1)) -> @F.%T.loc6_6.2 (%T) { // CHECK:STDOUT: !entry: @@ -743,6 +755,8 @@ fn G() -> C { // CHECK:STDOUT: %array_type.loc6_24.2 => constants.%array_type.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_27 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.4 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_type_mismatch.carbon @@ -750,7 +764,7 @@ fn G() -> C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %D: type = class_type @D [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -842,7 +856,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -850,7 +864,7 @@ fn G() -> C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @D { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%D diff --git a/toolchain/check/testdata/deduce/generic_type.carbon b/toolchain/check/testdata/deduce/generic_type.carbon index 3350f352bc52..bca8f464f5c1 100644 --- a/toolchain/check/testdata/deduce/generic_type.carbon +++ b/toolchain/check/testdata/deduce/generic_type.carbon @@ -78,6 +78,8 @@ fn G() -> i32 { // CHECK:STDOUT: %D: type = class_type @D [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %C.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%D) [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] @@ -174,6 +176,8 @@ fn G() -> i32 { // CHECK:STDOUT: %C.loc7_22.2: type = class_type @C, @C(%T.loc7_6.2) [symbolic = %C.loc7_22.2 (constants.%C.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_25: = require_complete_type @F.%T.loc7_6.2 (%T) [symbolic = %require_complete.loc7_25 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc7_17: = require_complete_type @F.%C.loc7_22.2 (%C.1) [symbolic = %require_complete.loc7_17 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc7_39.2: = specific_function constants.%F, @F(%T.loc7_6.2) [symbolic = %F.specific_fn.loc7_39.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%C.loc7_22.2 (%C.1)) -> @F.%T.loc7_6.2 (%T) { @@ -216,6 +220,8 @@ fn G() -> i32 { // CHECK:STDOUT: %C.loc7_22.2 => constants.%C.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_25 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc7_17 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc7_39.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -238,6 +244,8 @@ fn G() -> i32 { // CHECK:STDOUT: %C.loc7_22.2 => constants.%C.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_25 => constants.%complete_type +// CHECK:STDOUT: %require_complete.loc7_17 => constants.%complete_type // CHECK:STDOUT: %F.specific_fn.loc7_39.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -254,6 +262,7 @@ fn G() -> i32 { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %I.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %I.2: type = class_type @I, @I(%C) [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] @@ -350,6 +359,7 @@ fn G() -> i32 { // CHECK:STDOUT: %I.loc7_22.2: type = class_type @I, @I(%T.loc7_6.2) [symbolic = %I.loc7_22.2 (constants.%I.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%I.loc7_22.2 (%I.1) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %F.specific_fn.loc7_39.2: = specific_function constants.%F, @F(%T.loc7_6.2) [symbolic = %F.specific_fn.loc7_39.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%I.loc7_22.2 (%I.1)) -> %return.param_patt: %C { @@ -391,6 +401,7 @@ fn G() -> i32 { // CHECK:STDOUT: %I.loc7_22.2 => constants.%I.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %F.specific_fn.loc7_39.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -413,6 +424,7 @@ fn G() -> i32 { // CHECK:STDOUT: %I.loc7_22.2 => constants.%I.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: %F.specific_fn.loc7_39.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -430,14 +442,19 @@ fn G() -> i32 { // CHECK:STDOUT: %Inner.generic.1: %Inner.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %Inner.1: type = class_type @Inner, @Inner(%T, %U) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %D: type = class_type @D [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %Outer.1 [symbolic] // CHECK:STDOUT: %tuple.type.1: type = tuple_type (type, type) [template] // CHECK:STDOUT: %tuple.type.2: type = tuple_type (%T, %U) [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %tuple.type.2 [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %Inner.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T, %U) [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.5: = require_complete_type %U [symbolic] // CHECK:STDOUT: %Outer.2: type = class_type @Outer, @Outer(%C) [template] // CHECK:STDOUT: %Inner.type.2: type = generic_class_type @Inner, @Outer(%C) [template] // CHECK:STDOUT: %Inner.generic.2: %Inner.type.2 = struct_value () [template] @@ -446,6 +463,7 @@ fn G() -> i32 { // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn.2: = specific_function %F, @F(%C, %D) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %tuple.type.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -544,7 +562,7 @@ fn G() -> i32 { // CHECK:STDOUT: %U.param: type = value_param runtime_param // CHECK:STDOUT: %U.loc5_15.1: type = bind_symbolic_name U, 1, %U.param [symbolic = %U.loc5_15.2 (constants.%U)] // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Outer.1 @@ -560,7 +578,7 @@ fn G() -> i32 { // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Inner.1 @@ -569,7 +587,7 @@ fn G() -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -577,7 +595,7 @@ fn G() -> i32 { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @D { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%D @@ -590,13 +608,18 @@ fn G() -> i32 { // CHECK:STDOUT: %U.loc13_16.2: type = bind_symbolic_name U, 1 [symbolic = %U.loc13_16.2 (constants.%U)] // CHECK:STDOUT: %U.patt.loc13_16.2: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc13_16.2 (constants.%U.patt)] // CHECK:STDOUT: %Outer.loc13_36.2: type = class_type @Outer, @Outer(%T.loc13_6.2) [symbolic = %Outer.loc13_36.2 (constants.%Outer.1)] +// CHECK:STDOUT: %require_complete.loc13_37: = require_complete_type @F.%Outer.loc13_36.2 (%Outer.1) [symbolic = %require_complete.loc13_37 (constants.%require_complete.1)] // CHECK:STDOUT: %Inner.type: type = generic_class_type @Inner, @Outer(%T.loc13_6.2) [symbolic = %Inner.type (constants.%Inner.type.1)] // CHECK:STDOUT: %Inner.generic: @F.%Inner.type (%Inner.type.1) = struct_value () [symbolic = %Inner.generic (constants.%Inner.generic.1)] // CHECK:STDOUT: %Inner.loc13_45.2: type = class_type @Inner, @Inner(%T.loc13_6.2, %U.loc13_16.2) [symbolic = %Inner.loc13_45.2 (constants.%Inner.1)] // CHECK:STDOUT: %tuple.type: type = tuple_type (@F.%T.loc13_6.2 (%T), @F.%U.loc13_16.2 (%U)) [symbolic = %tuple.type (constants.%tuple.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc13_48: = require_complete_type @F.%tuple.type (%tuple.type.2) [symbolic = %require_complete.loc13_48 (constants.%require_complete.2)] +// CHECK:STDOUT: %require_complete.loc13_27: = require_complete_type @F.%Inner.loc13_45.2 (%Inner.1) [symbolic = %require_complete.loc13_27 (constants.%require_complete.3)] // CHECK:STDOUT: %F.specific_fn.loc13_67.2: = specific_function constants.%F, @F(%T.loc13_6.2, %U.loc13_16.2) [symbolic = %F.specific_fn.loc13_67.2 (constants.%F.specific_fn.1)] +// CHECK:STDOUT: %require_complete.loc13_70.1: = require_complete_type @F.%T.loc13_6.2 (%T) [symbolic = %require_complete.loc13_70.1 (constants.%require_complete.4)] +// CHECK:STDOUT: %require_complete.loc13_70.2: = require_complete_type @F.%U.loc13_16.2 (%U) [symbolic = %require_complete.loc13_70.2 (constants.%require_complete.5)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type, %U.param_patt: type](%p.param_patt: @F.%Inner.loc13_45.2 (%Inner.1)) -> %return.param_patt: @F.%tuple.type (%tuple.type.2) { // CHECK:STDOUT: !entry: @@ -667,13 +690,18 @@ fn G() -> i32 { // CHECK:STDOUT: %U.loc13_16.2 => constants.%U // CHECK:STDOUT: %U.patt.loc13_16.2 => constants.%U // CHECK:STDOUT: %Outer.loc13_36.2 => constants.%Outer.1 +// CHECK:STDOUT: %require_complete.loc13_37 => constants.%require_complete.1 // CHECK:STDOUT: %Inner.type => constants.%Inner.type.1 // CHECK:STDOUT: %Inner.generic => constants.%Inner.generic.1 // CHECK:STDOUT: %Inner.loc13_45.2 => constants.%Inner.1 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc13_48 => constants.%require_complete.2 +// CHECK:STDOUT: %require_complete.loc13_27 => constants.%require_complete.3 // CHECK:STDOUT: %F.specific_fn.loc13_67.2 => constants.%F.specific_fn.1 +// CHECK:STDOUT: %require_complete.loc13_70.1 => constants.%require_complete.4 +// CHECK:STDOUT: %require_complete.loc13_70.2 => constants.%require_complete.5 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F(%T.loc13_6.2, %U.loc13_16.2) { @@ -682,6 +710,7 @@ fn G() -> i32 { // CHECK:STDOUT: %U.loc13_16.2 => constants.%U // CHECK:STDOUT: %U.patt.loc13_16.2 => constants.%U // CHECK:STDOUT: %Outer.loc13_36.2 => constants.%Outer.1 +// CHECK:STDOUT: %require_complete.loc13_37 => constants.%require_complete.1 // CHECK:STDOUT: %Inner.type => constants.%Inner.type.1 // CHECK:STDOUT: %Inner.generic => constants.%Inner.generic.1 // CHECK:STDOUT: %Inner.loc13_45.2 => constants.%Inner.1 @@ -710,13 +739,18 @@ fn G() -> i32 { // CHECK:STDOUT: %U.loc13_16.2 => constants.%D // CHECK:STDOUT: %U.patt.loc13_16.2 => constants.%D // CHECK:STDOUT: %Outer.loc13_36.2 => constants.%Outer.2 +// CHECK:STDOUT: %require_complete.loc13_37 => constants.%complete_type.1 // CHECK:STDOUT: %Inner.type => constants.%Inner.type.2 // CHECK:STDOUT: %Inner.generic => constants.%Inner.generic.2 // CHECK:STDOUT: %Inner.loc13_45.2 => constants.%Inner.2 // CHECK:STDOUT: %tuple.type => constants.%tuple.type.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc13_48 => constants.%complete_type.2 +// CHECK:STDOUT: %require_complete.loc13_27 => constants.%complete_type.1 // CHECK:STDOUT: %F.specific_fn.loc13_67.2 => constants.%F.specific_fn.2 +// CHECK:STDOUT: %require_complete.loc13_70.1 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc13_70.2 => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- nontype.carbon @@ -732,9 +766,10 @@ fn G() -> i32 { // CHECK:STDOUT: %WithNontype.generic: %WithNontype.type = struct_value () [template] // CHECK:STDOUT: %WithNontype.1: type = class_type @WithNontype, @WithNontype(%N.1) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %WithNontype.1 [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] @@ -824,7 +859,7 @@ fn G() -> i32 { // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%WithNontype.1 @@ -838,6 +873,7 @@ fn G() -> i32 { // CHECK:STDOUT: %WithNontype.loc6_31.2: type = class_type @WithNontype, @WithNontype(%N.loc6_6.2) [symbolic = %WithNontype.loc6_31.2 (constants.%WithNontype.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%WithNontype.loc6_31.2 (%WithNontype.1) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%N.param_patt: %i32](%x.param_patt: @F.%WithNontype.loc6_31.2 (%WithNontype.1)) -> %i32 { // CHECK:STDOUT: !entry: @@ -902,5 +938,6 @@ fn G() -> i32 { // CHECK:STDOUT: %WithNontype.loc6_31.2 => constants.%WithNontype.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/deduce/int_float.carbon b/toolchain/check/testdata/deduce/int_float.carbon index 68b8d10f7ab0..90b616c100b4 100644 --- a/toolchain/check/testdata/deduce/int_float.carbon +++ b/toolchain/check/testdata/deduce/int_float.carbon @@ -48,11 +48,13 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %iN [symbolic] // CHECK:STDOUT: %int_64: Core.IntLiteral = int_value 64 [template] // CHECK:STDOUT: %i64: type = int_type signed, %int_64 [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%int_64) [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %i64 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -132,6 +134,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %iN: type = int_type signed, %N.loc4_6.2 [symbolic = %iN (constants.%iN)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%iN (%iN) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%N.param_patt: Core.IntLiteral](%n.param_patt: @F.%iN (%iN)) -> Core.IntLiteral { // CHECK:STDOUT: !entry: @@ -163,6 +166,7 @@ fn G(a: f64) -> Core.IntLiteral() { // CHECK:STDOUT: %iN => constants.%i64 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_todo_float.carbon diff --git a/toolchain/check/testdata/deduce/tuple.carbon b/toolchain/check/testdata/deduce/tuple.carbon index 0235b8a9faa4..1b6a7ba588e1 100644 --- a/toolchain/check/testdata/deduce/tuple.carbon +++ b/toolchain/check/testdata/deduce/tuple.carbon @@ -57,7 +57,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %D: type = class_type @D [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] @@ -67,11 +67,14 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple.type.2: type = tuple_type (%T, %U) [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %U [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %tuple.type.2 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T, %U) [symbolic] // CHECK:STDOUT: %tuple.type.3: type = tuple_type (%C, %D) [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn.2: = specific_function %F, @F(%C, %D) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %tuple.type.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -135,7 +138,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -143,7 +146,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @D { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%D @@ -158,6 +161,8 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple.type: type = tuple_type (@F.%T.loc7_6.2 (%T), @F.%U.loc7_16.2 (%U)) [symbolic = %tuple.type (constants.%tuple.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_40: = require_complete_type @F.%U.loc7_16.2 (%U) [symbolic = %require_complete.loc7_40 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc7_30: = require_complete_type @F.%tuple.type (%tuple.type.2) [symbolic = %require_complete.loc7_30 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc7_54.2: = specific_function constants.%F, @F(%T.loc7_6.2, %U.loc7_16.2) [symbolic = %F.specific_fn.loc7_54.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type, %U.param_patt: type](%pair.param_patt: @F.%tuple.type (%tuple.type.2)) -> @F.%U.loc7_16.2 (%U) { @@ -190,6 +195,8 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_40 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc7_30 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc7_54.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -209,6 +216,8 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc7_40 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc7_30 => constants.%complete_type.2 // CHECK:STDOUT: %F.specific_fn.loc7_54.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -227,7 +236,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %HasPair.generic: %HasPair.type = struct_value () [template] // CHECK:STDOUT: %HasPair.1: type = class_type @HasPair, @HasPair(%Pair) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %A: %i32 = bind_symbolic_name A, 0 [symbolic] // CHECK:STDOUT: %A.patt: %i32 = symbolic_binding_pattern A, 0 [symbolic] // CHECK:STDOUT: %B: %i32 = bind_symbolic_name B, 1 [symbolic] @@ -236,6 +245,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %HasPair.2: type = class_type @HasPair, @HasPair(%tuple.1) [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %HasPair.2 [symbolic] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] // CHECK:STDOUT: %tuple.type.3: type = tuple_type (Core.IntLiteral, Core.IntLiteral) [template] @@ -371,7 +381,7 @@ fn G(pair: (C, D)) -> D { // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%HasPair.1 @@ -388,6 +398,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %HasPair.loc6_41.2: type = class_type @HasPair, @HasPair(%tuple.loc6_40.2) [symbolic = %HasPair.loc6_41.2 (constants.%HasPair.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%HasPair.loc6_41.2 (%HasPair.2) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%A.param_patt: %i32, %B.param_patt: %i32](%h.param_patt: @F.%HasPair.loc6_41.2 (%HasPair.2)) -> %i32 { // CHECK:STDOUT: !entry: @@ -449,6 +460,7 @@ fn G(pair: (C, D)) -> D { // CHECK:STDOUT: %HasPair.loc6_41.2 => constants.%HasPair.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_inconsistent.carbon diff --git a/toolchain/check/testdata/deduce/type_operator.carbon b/toolchain/check/testdata/deduce/type_operator.carbon index c67b4c892978..d7cccd9beef0 100644 --- a/toolchain/check/testdata/deduce/type_operator.carbon +++ b/toolchain/check/testdata/deduce/type_operator.carbon @@ -67,17 +67,20 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %ptr.2: type = ptr_type %C [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn.2: = specific_function %F, @F(%C) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %ptr.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -131,7 +134,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -144,6 +147,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2: type = ptr_type @F.%T.loc6_6.2 (%T) [symbolic = %ptr.loc6_20.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_23 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%ptr.loc6_20.2 (%ptr.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc6_37.2: = specific_function constants.%F, @F(%T.loc6_6.2) [symbolic = %F.specific_fn.loc6_37.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%ptr.loc6_20.2 (%ptr.1)) -> @F.%T.loc6_6.2 (%T) { @@ -174,6 +179,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc6_37.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -189,6 +196,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.2 // CHECK:STDOUT: %F.specific_fn.loc6_37.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -197,19 +206,22 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %const.1: type = const_type %T [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %const.1 [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %const.2: type = const_type %C [template] // CHECK:STDOUT: %ptr.2: type = ptr_type %const.2 [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn.2: = specific_function %F, @F(%C) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %ptr.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -265,7 +277,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -279,6 +291,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_26.2: type = ptr_type @F.%const.loc6_19.2 (%const.1) [symbolic = %ptr.loc6_26.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_29: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_29 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%ptr.loc6_26.2 (%ptr.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc6_43.2: = specific_function constants.%F, @F(%T.loc6_6.2) [symbolic = %F.specific_fn.loc6_43.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%ptr.loc6_26.2 (%ptr.1)) -> @F.%T.loc6_6.2 (%T) { @@ -310,6 +324,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_26.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_29 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc6_43.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -327,6 +343,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_26.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_29 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.2 // CHECK:STDOUT: %F.specific_fn.loc6_43.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -335,18 +353,21 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: constants { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %F.specific_fn.1: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %const: type = const_type %C [template] // CHECK:STDOUT: %ptr.2: type = ptr_type %const [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %F.specific_fn.2: = specific_function %F, @F(%const) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %ptr.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -402,7 +423,7 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @C { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C @@ -415,6 +436,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2: type = ptr_type @F.%T.loc6_6.2 (%T) [symbolic = %ptr.loc6_20.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_23 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%ptr.loc6_20.2 (%ptr.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc6_37.2: = specific_function constants.%F, @F(%T.loc6_6.2) [symbolic = %F.specific_fn.loc6_37.2 (constants.%F.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%ptr.loc6_20.2 (%ptr.1)) -> @F.%T.loc6_6.2 (%T) { @@ -445,6 +468,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc6_37.2 => constants.%F.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -460,6 +485,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_20.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_23 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%complete_type.2 // CHECK:STDOUT: %F.specific_fn.loc6_37.2 => constants.%F.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -475,6 +502,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.1: type = ptr_type %const.1 [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: %ptr.2: type = ptr_type %C [template] // CHECK:STDOUT: %const.2: type = const_type %C [template] @@ -549,6 +578,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_26.2: type = ptr_type @F.%const.loc6_19.2 (%const.1) [symbolic = %ptr.loc6_26.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_29: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete.loc6_29 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_17: = require_complete_type @F.%ptr.loc6_26.2 (%ptr.1) [symbolic = %require_complete.loc6_17 (constants.%require_complete.2)] // CHECK:STDOUT: %F.specific_fn.loc6_43.2: = specific_function constants.%F, @F(%T.loc6_6.2) [symbolic = %F.specific_fn.loc6_43.2 (constants.%F.specific_fn)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%p.param_patt: @F.%ptr.loc6_26.2 (%ptr.1)) -> @F.%T.loc6_6.2 (%T) { @@ -577,6 +608,8 @@ fn G(p: C*) -> const C { // CHECK:STDOUT: %ptr.loc6_26.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_29 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc6_17 => constants.%require_complete.2 // CHECK:STDOUT: %F.specific_fn.loc6_43.2 => constants.%F.specific_fn // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/eval/symbolic.carbon b/toolchain/check/testdata/eval/symbolic.carbon index 516d5b6f0bc6..6d79a08c24fa 100644 --- a/toolchain/check/testdata/eval/symbolic.carbon +++ b/toolchain/check/testdata/eval/symbolic.carbon @@ -26,9 +26,12 @@ fn F(T:! type) { // CHECK:STDOUT: %const: type = const_type %T [symbolic] // CHECK:STDOUT: %tuple.type.1: type = tuple_type (type, type) [template] // CHECK:STDOUT: %tuple.type.2: type = tuple_type (%ptr.1, %const) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %tuple.type.2 [symbolic] // CHECK:STDOUT: %struct_type.a: type = struct_type {.a: %T} [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %struct_type.a [symbolic] // CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [template] // CHECK:STDOUT: %array_type: type = array_type %int_5, %T [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %array_type [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -61,8 +64,11 @@ fn F(T:! type) { // CHECK:STDOUT: %ptr.loc13_12.2: type = ptr_type @F.%T.loc12_6.2 (%T) [symbolic = %ptr.loc13_12.2 (constants.%ptr.1)] // CHECK:STDOUT: %const.loc13_15.2: type = const_type @F.%T.loc12_6.2 (%T) [symbolic = %const.loc13_15.2 (constants.%const)] // CHECK:STDOUT: %tuple.type: type = tuple_type (@F.%ptr.loc13_12.2 (%ptr.1), @F.%const.loc13_15.2 (%const)) [symbolic = %tuple.type (constants.%tuple.type.2)] +// CHECK:STDOUT: %require_complete.loc13: = require_complete_type @F.%tuple.type (%tuple.type.2) [symbolic = %require_complete.loc13 (constants.%require_complete.1)] // CHECK:STDOUT: %struct_type.a.loc14_16.2: type = struct_type {.a: @F.%T.loc12_6.2 (%T)} [symbolic = %struct_type.a.loc14_16.2 (constants.%struct_type.a)] +// CHECK:STDOUT: %require_complete.loc14: = require_complete_type @F.%struct_type.a.loc14_16.2 (%struct_type.a) [symbolic = %require_complete.loc14 (constants.%require_complete.2)] // CHECK:STDOUT: %array_type.loc15_15.2: type = array_type constants.%int_5, @F.%T.loc12_6.2 (%T) [symbolic = %array_type.loc15_15.2 (constants.%array_type)] +// CHECK:STDOUT: %require_complete.loc15: = require_complete_type @F.%array_type.loc15_15.2 (%array_type) [symbolic = %require_complete.loc15 (constants.%require_complete.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon b/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon index c5be59747250..c686caf50b0c 100644 --- a/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon +++ b/toolchain/check/testdata/function/call/prefer_unqualified_lookup.carbon @@ -42,7 +42,7 @@ fn Class(F:! type).Inner.G() -> i32 { return F(); } // CHECK:STDOUT: %G.type: type = fn_type @G, @Inner(%F.1) [symbolic] // CHECK:STDOUT: %G: %G.type = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_0.1: Core.IntLiteral = int_value 0 [template] // CHECK:STDOUT: %Convert.type.2: type = fn_type @Convert.1, @ImplicitAs(%i32) [template] // CHECK:STDOUT: %Convert.type.14: type = fn_type @Convert.2, @impl.1(%int_32) [template] @@ -99,7 +99,7 @@ fn Class(F:! type).Inner.G() -> i32 { return F(); } // CHECK:STDOUT: // CHECK:STDOUT: class { // CHECK:STDOUT: %Inner.decl: type = class_decl @Inner [template = constants.%Inner.1] {} {} -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Class @@ -139,7 +139,7 @@ fn Class(F:! type).Inner.G() -> i32 { return F(); } // CHECK:STDOUT: %return.param.loc9: ref %i32 = out_param runtime_param0 // CHECK:STDOUT: %return.loc9: ref %i32 = return_slot %return.param.loc9 // CHECK:STDOUT: } -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%Inner.2 diff --git a/toolchain/check/testdata/function/declaration/no_prelude/fail_import_incomplete_return.carbon b/toolchain/check/testdata/function/declaration/no_prelude/fail_import_incomplete_return.carbon index 99f0021778a3..26a536920ffc 100644 --- a/toolchain/check/testdata/function/declaration/no_prelude/fail_import_incomplete_return.carbon +++ b/toolchain/check/testdata/function/declaration/no_prelude/fail_import_incomplete_return.carbon @@ -23,7 +23,7 @@ fn ReturnDUsed() -> D; fn Call() { // CHECK:STDERR: fail_incomplete_return.carbon:[[@LINE+10]]:3: error: function returns incomplete type `C` [IncompleteTypeInFunctionReturnType] // CHECK:STDERR: ReturnCUsed(); - // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~ // CHECK:STDERR: fail_incomplete_return.carbon:[[@LINE-12]]:1: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; // CHECK:STDERR: ^~~~~~~~ @@ -34,7 +34,7 @@ fn Call() { ReturnCUsed(); // CHECK:STDERR: fail_incomplete_return.carbon:[[@LINE+10]]:3: error: function returns incomplete type `D` [IncompleteTypeInFunctionReturnType] // CHECK:STDERR: ReturnDUsed(); - // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~ // CHECK:STDERR: fail_incomplete_return.carbon:[[@LINE-22]]:1: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class D; // CHECK:STDERR: ^~~~~~~~ @@ -56,7 +56,7 @@ import library "incomplete_return"; fn CallFAndGIncomplete() { // CHECK:STDERR: fail_use_imported.carbon:[[@LINE+12]]:3: error: function returns incomplete type `C` [IncompleteTypeInFunctionReturnType] // CHECK:STDERR: ReturnCUnused(); - // CHECK:STDERR: ^~~~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~~~ // CHECK:STDERR: fail_use_imported.carbon:[[@LINE-6]]:1: in import [InImport] // CHECK:STDERR: fail_incomplete_return.carbon:4:1: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; @@ -69,7 +69,7 @@ fn CallFAndGIncomplete() { ReturnCUnused(); // CHECK:STDERR: fail_use_imported.carbon:[[@LINE+11]]:3: error: function returns incomplete type `C` [IncompleteTypeInFunctionReturnType] // CHECK:STDERR: ReturnCUsed(); - // CHECK:STDERR: ^~~~~~~~~~~ + // CHECK:STDERR: ^~~~~~~~~~~~~ // CHECK:STDERR: fail_use_imported.carbon:[[@LINE-19]]:1: in import [InImport] // CHECK:STDERR: fail_incomplete_return.carbon:4:1: note: class was forward declared here [ClassForwardDeclaredHere] // CHECK:STDERR: class C; diff --git a/toolchain/check/testdata/function/generic/deduce.carbon b/toolchain/check/testdata/function/generic/deduce.carbon index 20800f5e991d..a93133a675c4 100644 --- a/toolchain/check/testdata/function/generic/deduce.carbon +++ b/toolchain/check/testdata/function/generic/deduce.carbon @@ -198,6 +198,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %ExplicitGenericParam.type: type = fn_type @ExplicitGenericParam [template] // CHECK:STDOUT: %ExplicitGenericParam: %ExplicitGenericParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.1: = specific_function %ExplicitGenericParam, @ExplicitGenericParam(%T) [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -211,7 +212,9 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.3: type = ptr_type %struct_type.a [symbolic] // CHECK:STDOUT: %CallExplicitGenericParamWithGenericArg.type: type = fn_type @CallExplicitGenericParamWithGenericArg [template] // CHECK:STDOUT: %CallExplicitGenericParamWithGenericArg: %CallExplicitGenericParamWithGenericArg.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.3 [symbolic] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.3: = specific_function %ExplicitGenericParam, @ExplicitGenericParam(%struct_type.a) [symbolic] +// CHECK:STDOUT: %complete_type: = complete_type_witness %ptr.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -277,6 +280,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2: type = ptr_type @ExplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %ptr.loc4_39.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @ExplicitGenericParam.%ptr.loc4_39.2 (%ptr.1) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2: = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%T.loc4_25.2) [symbolic = %ExplicitGenericParam.specific_fn.loc4_50.2 (constants.%ExplicitGenericParam.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> @ExplicitGenericParam.%ptr.loc4_39.2 (%ptr.1) { @@ -312,6 +316,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc10_63.2: type = ptr_type @CallExplicitGenericParamWithGenericArg.%struct_type.a.loc10_62.2 (%struct_type.a) [symbolic = %ptr.loc10_63.2 (constants.%ptr.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallExplicitGenericParamWithGenericArg.%ptr.loc10_63.2 (%ptr.3) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc11_10.2: = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%struct_type.a.loc10_62.2) [symbolic = %ExplicitGenericParam.specific_fn.loc11_10.2 (constants.%ExplicitGenericParam.specific_fn.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> @CallExplicitGenericParamWithGenericArg.%ptr.loc10_63.2 (%ptr.3) { @@ -333,6 +338,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2 => constants.%ExplicitGenericParam.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -348,6 +354,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2 => constants.%ExplicitGenericParam.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -364,6 +371,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2 => constants.%ptr.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.2 // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2 => constants.%ExplicitGenericParam.specific_fn.3 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -381,6 +389,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] // CHECK:STDOUT: %ExplicitGenericParam.type: type = fn_type @ExplicitGenericParam [template] // CHECK:STDOUT: %ExplicitGenericParam: %ExplicitGenericParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %ptr [symbolic] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn: = specific_function %ExplicitGenericParam, @ExplicitGenericParam(%T) [symbolic] // CHECK:STDOUT: %CallExplicitGenericParamConst.type: type = fn_type @CallExplicitGenericParamConst [template] // CHECK:STDOUT: %CallExplicitGenericParamConst: %CallExplicitGenericParamConst.type = struct_value () [template] @@ -438,6 +447,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2: type = ptr_type @ExplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %ptr.loc4_39.2 (constants.%ptr)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @ExplicitGenericParam.%ptr.loc4_39.2 (%ptr) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2: = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%T.loc4_25.2) [symbolic = %ExplicitGenericParam.specific_fn.loc4_50.2 (constants.%ExplicitGenericParam.specific_fn)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> @ExplicitGenericParam.%ptr.loc4_39.2 (%ptr) { @@ -459,6 +469,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc7_3.2: = specific_function constants.%ExplicitGenericParam, @ExplicitGenericParam(%T.loc6_34.2) [symbolic = %ExplicitGenericParam.specific_fn.loc7_3.2 (constants.%ExplicitGenericParam.specific_fn)] // CHECK:STDOUT: %ptr: type = ptr_type @CallExplicitGenericParamConst.%T.loc6_34.2 (%T) [symbolic = %ptr (constants.%ptr)] +// CHECK:STDOUT: %require_complete: = require_complete_type @CallExplicitGenericParamConst.%ptr (%ptr) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { // CHECK:STDOUT: !entry: @@ -483,6 +494,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_39.2 => constants.%ptr // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %ExplicitGenericParam.specific_fn.loc4_50.2 => constants.%ExplicitGenericParam.specific_fn // CHECK:STDOUT: } // CHECK:STDOUT: @@ -508,18 +520,21 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: constants { // CHECK:STDOUT: %A: type = class_type @A [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %ExplicitAndAlsoDeduced.type: type = fn_type @ExplicitAndAlsoDeduced [template] // CHECK:STDOUT: %ExplicitAndAlsoDeduced: %ExplicitAndAlsoDeduced.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr.1 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.1: = specific_function %ExplicitAndAlsoDeduced, @ExplicitAndAlsoDeduced(%T) [symbolic] // CHECK:STDOUT: %ptr.2: type = ptr_type %A [template] // CHECK:STDOUT: %CallExplicitAndAlsoDeduced.type: type = fn_type @CallExplicitAndAlsoDeduced [template] // CHECK:STDOUT: %CallExplicitAndAlsoDeduced: %CallExplicitAndAlsoDeduced.type = struct_value () [template] // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.2: = specific_function %ExplicitAndAlsoDeduced, @ExplicitAndAlsoDeduced(%A) [template] // CHECK:STDOUT: %A.val: %A = struct_value () [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %ptr.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -568,7 +583,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @A { -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%A @@ -581,6 +596,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc6_47.2: type = ptr_type @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) [symbolic = %ptr.loc6_47.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_43: = require_complete_type @ExplicitAndAlsoDeduced.%ptr.loc6_47.2 (%ptr.1) [symbolic = %require_complete.loc6_43 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc6_38: = require_complete_type @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T) [symbolic = %require_complete.loc6_38 (constants.%require_complete.2)] // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.loc7_10.2: = specific_function constants.%ExplicitAndAlsoDeduced, @ExplicitAndAlsoDeduced(%T.loc6_27.2) [symbolic = %ExplicitAndAlsoDeduced.specific_fn.loc7_10.2 (constants.%ExplicitAndAlsoDeduced.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @ExplicitAndAlsoDeduced.%T.loc6_27.2 (%T)) -> @ExplicitAndAlsoDeduced.%ptr.loc6_47.2 (%ptr.1) { @@ -619,6 +636,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc6_47.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_43 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc6_38 => constants.%require_complete.2 // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.loc7_10.2 => constants.%ExplicitAndAlsoDeduced.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -634,6 +653,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc6_47.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc6_43 => constants.%complete_type.2 +// CHECK:STDOUT: %require_complete.loc6_38 => constants.%complete_type.1 // CHECK:STDOUT: %ExplicitAndAlsoDeduced.specific_fn.loc7_10.2 => constants.%ExplicitAndAlsoDeduced.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -645,6 +666,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %ImplicitGenericParam.type: type = fn_type @ImplicitGenericParam [template] // CHECK:STDOUT: %ImplicitGenericParam: %ImplicitGenericParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr.1 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.1: = specific_function %ImplicitGenericParam, @ImplicitGenericParam(%T) [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] @@ -654,6 +677,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %CallImplicitGenericParam.type: type = fn_type @CallImplicitGenericParam [template] // CHECK:STDOUT: %CallImplicitGenericParam: %CallImplicitGenericParam.type = struct_value () [template] // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.2: = specific_function %ImplicitGenericParam, @ImplicitGenericParam(%i32) [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %ptr.2 [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -717,6 +742,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_45.2: type = ptr_type @ImplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %ptr.loc4_45.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc4_41: = require_complete_type @ImplicitGenericParam.%ptr.loc4_45.2 (%ptr.1) [symbolic = %require_complete.loc4_41 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc4_36: = require_complete_type @ImplicitGenericParam.%T.loc4_25.2 (%T) [symbolic = %require_complete.loc4_36 (constants.%require_complete.2)] // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.loc4_56.2: = specific_function constants.%ImplicitGenericParam, @ImplicitGenericParam(%T.loc4_25.2) [symbolic = %ImplicitGenericParam.specific_fn.loc4_56.2 (constants.%ImplicitGenericParam.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @ImplicitGenericParam.%T.loc4_25.2 (%T)) -> @ImplicitGenericParam.%ptr.loc4_45.2 (%ptr.1) { @@ -748,6 +775,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_45.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc4_41 => constants.%require_complete.1 +// CHECK:STDOUT: %require_complete.loc4_36 => constants.%require_complete.2 // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.loc4_56.2 => constants.%ImplicitGenericParam.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -763,6 +792,8 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %ptr.loc4_45.2 => constants.%ptr.2 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc4_41 => constants.%complete_type.1 +// CHECK:STDOUT: %require_complete.loc4_36 => constants.%complete_type.2 // CHECK:STDOUT: %ImplicitGenericParam.specific_fn.loc4_56.2 => constants.%ImplicitGenericParam.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -780,6 +811,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %tuple.type.2: type = tuple_type (%T, %i32) [symbolic] // CHECK:STDOUT: %TupleParam.type: type = fn_type @TupleParam [template] // CHECK:STDOUT: %TupleParam: %TupleParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %tuple.type.2 [symbolic] // CHECK:STDOUT: %CallTupleParam.type: type = fn_type @CallTupleParam [template] // CHECK:STDOUT: %CallTupleParam: %CallTupleParam.type = struct_value () [template] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] @@ -795,6 +827,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_2.2: %i32 = int_value 2 [template] // CHECK:STDOUT: %tuple: %tuple.type.4 = tuple_value (%int_1, %int_2.2) [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %tuple.type.4 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -840,6 +873,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %tuple.type: type = tuple_type (@TupleParam.%T.loc4_15.2 (%T), %i32) [symbolic = %tuple.type (constants.%tuple.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @TupleParam.%tuple.type (%tuple.type.2) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @TupleParam.%tuple.type (%tuple.type.2)) { // CHECK:STDOUT: !entry: @@ -878,6 +912,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %tuple.type => constants.%tuple.type.4 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- deduce_nested_struct.carbon @@ -893,6 +928,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %T, .b: %i32} [symbolic] // CHECK:STDOUT: %StructParam.type: type = fn_type @StructParam [template] // CHECK:STDOUT: %StructParam: %StructParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %struct_type.a.b.1 [symbolic] // CHECK:STDOUT: %CallStructParam.type: type = fn_type @CallStructParam [template] // CHECK:STDOUT: %CallStructParam: %CallStructParam.type = struct_value () [template] // CHECK:STDOUT: %int_1: Core.IntLiteral = int_value 1 [template] @@ -908,6 +944,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.2(%int_32) [template] // CHECK:STDOUT: %int_2.2: %i32 = int_value 2 [template] // CHECK:STDOUT: %struct: %struct_type.a.b.3 = struct_value (%int_1, %int_2.2) [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.a.b.3 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -952,6 +989,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.a.b.loc4_44.2: type = struct_type {.a: @StructParam.%T.loc4_16.2 (%T), .b: %i32} [symbolic = %struct_type.a.b.loc4_44.2 (constants.%struct_type.a.b.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @StructParam.%struct_type.a.b.loc4_44.2 (%struct_type.a.b.1) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @StructParam.%struct_type.a.b.loc4_44.2 (%struct_type.a.b.1)) { // CHECK:STDOUT: !entry: @@ -990,6 +1028,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.a.b.loc4_44.2 => constants.%struct_type.a.b.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_deduce_bigger_struct.carbon @@ -1004,6 +1043,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.c.d.e: type = struct_type {.c: %T, .d: %i32, .e: %i32} [symbolic] // CHECK:STDOUT: %BigStructParam.type: type = fn_type @BigStructParam [template] // CHECK:STDOUT: %BigStructParam: %BigStructParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %struct_type.c.d.e [symbolic] // CHECK:STDOUT: %CallBigStructParam.type: type = fn_type @CallBigStructParam [template] // CHECK:STDOUT: %CallBigStructParam: %CallBigStructParam.type = struct_value () [template] // CHECK:STDOUT: %int_3: Core.IntLiteral = int_value 3 [template] @@ -1056,6 +1096,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.c.d.e.loc4_56.2: type = struct_type {.c: @BigStructParam.%T.loc4_19.2 (%T), .d: %i32, .e: %i32} [symbolic = %struct_type.c.d.e.loc4_56.2 (constants.%struct_type.c.d.e)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @BigStructParam.%struct_type.c.d.e.loc4_56.2 (%struct_type.c.d.e) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @BigStructParam.%struct_type.c.d.e.loc4_56.2 (%struct_type.c.d.e)) { // CHECK:STDOUT: !entry: @@ -1090,6 +1131,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.f.g: type = struct_type {.f: %T, .g: %i32} [symbolic] // CHECK:STDOUT: %SmallStructParam.type: type = fn_type @SmallStructParam [template] // CHECK:STDOUT: %SmallStructParam: %SmallStructParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %struct_type.f.g [symbolic] // CHECK:STDOUT: %CallSmallStructParam.type: type = fn_type @CallSmallStructParam [template] // CHECK:STDOUT: %CallSmallStructParam: %CallSmallStructParam.type = struct_value () [template] // CHECK:STDOUT: %int_5: Core.IntLiteral = int_value 5 [template] @@ -1139,6 +1181,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.f.g.loc4_49.2: type = struct_type {.f: @SmallStructParam.%T.loc4_21.2 (%T), .g: %i32} [symbolic = %struct_type.f.g.loc4_49.2 (constants.%struct_type.f.g)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @SmallStructParam.%struct_type.f.g.loc4_49.2 (%struct_type.f.g) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @SmallStructParam.%struct_type.f.g.loc4_49.2 (%struct_type.f.g)) { // CHECK:STDOUT: !entry: @@ -1174,6 +1217,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.i.different: type = struct_type {.i: %T, .different: %i32} [symbolic] // CHECK:STDOUT: %WrongNameStructParam.type: type = fn_type @WrongNameStructParam [template] // CHECK:STDOUT: %WrongNameStructParam: %WrongNameStructParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %struct_type.i.different [symbolic] // CHECK:STDOUT: %CallWrongNameStructParam.type: type = fn_type @CallWrongNameStructParam [template] // CHECK:STDOUT: %CallWrongNameStructParam: %CallWrongNameStructParam.type = struct_value () [template] // CHECK:STDOUT: %int_8: Core.IntLiteral = int_value 8 [template] @@ -1222,6 +1266,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.i.different.loc4_61.2: type = struct_type {.i: @WrongNameStructParam.%T.loc4_25.2 (%T), .different: %i32} [symbolic = %struct_type.i.different.loc4_61.2 (constants.%struct_type.i.different)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @WrongNameStructParam.%struct_type.i.different.loc4_61.2 (%struct_type.i.different) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @WrongNameStructParam.%struct_type.i.different.loc4_61.2 (%struct_type.i.different)) { // CHECK:STDOUT: !entry: @@ -1256,6 +1301,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.first.second: type = struct_type {.first: %T, .second: %i32} [symbolic] // CHECK:STDOUT: %WrongOrderStructParam.type: type = fn_type @WrongOrderStructParam [template] // CHECK:STDOUT: %WrongOrderStructParam: %WrongOrderStructParam.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %struct_type.first.second [symbolic] // CHECK:STDOUT: %CallWrongOrderStructParam.type: type = fn_type @CallWrongOrderStructParam [template] // CHECK:STDOUT: %CallWrongOrderStructParam: %CallWrongOrderStructParam.type = struct_value () [template] // CHECK:STDOUT: %int_11: Core.IntLiteral = int_value 11 [template] @@ -1304,6 +1350,7 @@ fn CallImplicitNotDeducible() { // CHECK:STDOUT: %struct_type.first.second.loc4_63.2: type = struct_type {.first: @WrongOrderStructParam.%T.loc4_26.2 (%T), .second: %i32} [symbolic = %struct_type.first.second.loc4_63.2 (constants.%struct_type.first.second)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @WrongOrderStructParam.%struct_type.first.second.loc4_63.2 (%struct_type.first.second) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @WrongOrderStructParam.%struct_type.first.second.loc4_63.2 (%struct_type.first.second)) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/no_prelude/call.carbon b/toolchain/check/testdata/function/generic/no_prelude/call.carbon index 2fe6b5f7a030..c758b59a9445 100644 --- a/toolchain/check/testdata/function/generic/no_prelude/call.carbon +++ b/toolchain/check/testdata/function/generic/no_prelude/call.carbon @@ -59,12 +59,14 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %Function.type: type = fn_type @Function [template] // CHECK:STDOUT: %Function: %Function.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template] // CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template] // CHECK:STDOUT: %Function.specific_fn.1: = specific_function %Function, @Function(%T) [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template] // CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %Function.specific_fn.2: = specific_function %Function, @Function(%ptr.1) [symbolic] // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] @@ -164,6 +166,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Function.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) { // CHECK:STDOUT: !entry: @@ -177,6 +180,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallGeneric.%T.loc8_16.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Function.specific_fn.loc9_10.2: = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) { @@ -198,6 +202,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %ptr.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %Function.specific_fn.loc13_10.2: = specific_function constants.%Function, @Function(%ptr.loc12_33.2) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1)) -> @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) { @@ -230,6 +235,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @CallGeneric(constants.%T) { @@ -253,6 +259,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Function(@CallGenericPtr.%ptr.loc12_33.2) { @@ -265,6 +272,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%C // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- deduced.carbon @@ -274,12 +282,14 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %Function.type: type = fn_type @Function [template] // CHECK:STDOUT: %Function: %Function.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %CallGeneric.type: type = fn_type @CallGeneric [template] // CHECK:STDOUT: %CallGeneric: %CallGeneric.type = struct_value () [template] // CHECK:STDOUT: %Function.specific_fn.1: = specific_function %Function, @Function(%T) [symbolic] // CHECK:STDOUT: %ptr.1: type = ptr_type %T [symbolic] // CHECK:STDOUT: %CallGenericPtr.type: type = fn_type @CallGenericPtr [template] // CHECK:STDOUT: %CallGenericPtr: %CallGenericPtr.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.1 [symbolic] // CHECK:STDOUT: %Function.specific_fn.2: = specific_function %Function, @Function(%ptr.1) [symbolic] // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] @@ -379,6 +389,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_13.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Function.%T.loc4_13.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @Function.%T.loc4_13.2 (%T)) -> @Function.%T.loc4_13.2 (%T) { // CHECK:STDOUT: !entry: @@ -392,6 +403,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc8_16.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc8_16.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallGeneric.%T.loc8_16.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Function.specific_fn.loc9_10.2: = specific_function constants.%Function, @Function(%T.loc8_16.2) [symbolic = %Function.specific_fn.loc9_10.2 (constants.%Function.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGeneric.%T.loc8_16.2 (%T)) -> @CallGeneric.%T.loc8_16.2 (%T) { @@ -412,6 +424,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %ptr.loc12_33.2: type = ptr_type @CallGenericPtr.%T.loc12_19.2 (%T) [symbolic = %ptr.loc12_33.2 (constants.%ptr.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %Function.specific_fn.loc13_10.2: = specific_function constants.%Function, @Function(%ptr.loc12_33.2) [symbolic = %Function.specific_fn.loc13_10.2 (constants.%Function.specific_fn.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %x.param_patt: @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1)) -> @CallGenericPtr.%ptr.loc12_33.2 (%ptr.1) { @@ -441,6 +454,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @CallGeneric(constants.%T) { @@ -464,6 +478,7 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%ptr.1 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @Function(@CallGenericPtr.%ptr.loc12_33.2) { @@ -476,5 +491,6 @@ fn CallSpecific(x: C) -> C { // CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%C // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon b/toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon index 0f15fed2c8ea..129e728e8d72 100644 --- a/toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon +++ b/toolchain/check/testdata/function/generic/no_prelude/fail_type_param_mismatch.carbon @@ -26,6 +26,8 @@ fn F(T:! type, U:! type) { // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %U [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -53,6 +55,8 @@ fn F(T:! type, U:! type) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %ptr.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %ptr.loc12_11.2 (constants.%ptr)] +// CHECK:STDOUT: %require_complete.loc12: = require_complete_type @F.%ptr.loc12_11.2 (%ptr) [symbolic = %require_complete.loc12 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc16: = require_complete_type @F.%U.loc11_16.2 (%U) [symbolic = %require_complete.loc16 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon b/toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon index 323a5cc6f694..481c6f2ac1b9 100644 --- a/toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon +++ b/toolchain/check/testdata/function/generic/no_prelude/indirect_generic_type.carbon @@ -21,6 +21,8 @@ fn F(T:! type, p: T**) -> T* { // CHECK:STDOUT: %ptr.2: type = ptr_type %ptr.1 [symbolic] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr.1 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %ptr.2 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -56,6 +58,8 @@ fn F(T:! type, p: T**) -> T* { // CHECK:STDOUT: %ptr.loc11_21.2: type = ptr_type @F.%ptr.loc11_20.2 (%ptr.1) [symbolic = %ptr.loc11_21.2 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc11_24: = require_complete_type @F.%ptr.loc11_20.2 (%ptr.1) [symbolic = %require_complete.loc11_24 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc11_17: = require_complete_type @F.%ptr.loc11_21.2 (%ptr.2) [symbolic = %require_complete.loc11_17 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %p.param_patt: @F.%ptr.loc11_21.2 (%ptr.2)) -> @F.%ptr.loc11_20.2 (%ptr.1) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/no_prelude/type_param.carbon b/toolchain/check/testdata/function/generic/no_prelude/type_param.carbon index 44ed8f97931b..3e7ec0ecb1a8 100644 --- a/toolchain/check/testdata/function/generic/no_prelude/type_param.carbon +++ b/toolchain/check/testdata/function/generic/no_prelude/type_param.carbon @@ -21,6 +21,8 @@ fn F(T:! type) { // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %ptr [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -42,6 +44,8 @@ fn F(T:! type) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %ptr.loc12_11.2: type = ptr_type @F.%T.loc11_6.2 (%T) [symbolic = %ptr.loc12_11.2 (constants.%ptr)] +// CHECK:STDOUT: %require_complete.loc12: = require_complete_type @F.%ptr.loc12_11.2 (%ptr) [symbolic = %require_complete.loc12 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc13: = require_complete_type @F.%T.loc11_6.2 (%T) [symbolic = %require_complete.loc13 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/no_prelude/type_param_scope.carbon b/toolchain/check/testdata/function/generic/no_prelude/type_param_scope.carbon index 4629d97a0122..3c7dadd197e3 100644 --- a/toolchain/check/testdata/function/generic/no_prelude/type_param_scope.carbon +++ b/toolchain/check/testdata/function/generic/no_prelude/type_param_scope.carbon @@ -20,6 +20,7 @@ fn F(T:! type, n: T) -> T { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [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 %T [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -50,6 +51,7 @@ fn F(T:! type, n: T) -> T { // CHECK:STDOUT: %T.patt.loc11_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc11_6.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T.loc11_6.2 (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %n.param_patt: @F.%T.loc11_6.2 (%T)) -> @F.%T.loc11_6.2 (%T) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/redeclare.carbon b/toolchain/check/testdata/function/generic/redeclare.carbon index fc99ab8c419a..d235370022fb 100644 --- a/toolchain/check/testdata/function/generic/redeclare.carbon +++ b/toolchain/check/testdata/function/generic/redeclare.carbon @@ -97,6 +97,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr: type = ptr_type %T [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 %ptr [symbolic] // CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%T) [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -147,6 +148,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.loc4_20.2: type = ptr_type @F.%T.loc4_6.2 (%T) [symbolic = %ptr.loc4_20.2 (constants.%ptr)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%ptr.loc4_20.2 (%ptr) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %F.specific_fn.loc7_10.2: = specific_function constants.%F, @F(%T.loc4_6.2) [symbolic = %F.specific_fn.loc7_10.2 (constants.%F.specific_fn)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> %ptr { @@ -167,6 +169,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.loc4_20.2 => constants.%ptr // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %F.specific_fn.loc7_10.2 => constants.%F.specific_fn // CHECK:STDOUT: } // CHECK:STDOUT: @@ -189,6 +192,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.2: type = ptr_type %U [symbolic] // CHECK:STDOUT: %.type: type = fn_type @.1 [template] // CHECK:STDOUT: %.1: %.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %ptr.2 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -258,6 +262,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%U.loc13_16.2 (%U) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @.1.%ptr.loc13_30.2 (%ptr.2) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) { // CHECK:STDOUT: !entry: @@ -300,6 +305,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.2: type = ptr_type %T.2 [symbolic] // CHECK:STDOUT: %.type: type = fn_type @.1 [template] // CHECK:STDOUT: %.1: %.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %ptr.2 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -369,6 +375,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%T.loc13_16.2 (%T.2) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @.1.%ptr.loc13_30.2 (%ptr.2) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) { // CHECK:STDOUT: !entry: @@ -411,6 +418,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.2: type = ptr_type %U.2 [symbolic] // CHECK:STDOUT: %.type: type = fn_type @.1 [template] // CHECK:STDOUT: %.1: %.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %ptr.2 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -480,6 +488,7 @@ fn F(U:! type, T:! type) -> U* { // CHECK:STDOUT: %ptr.loc13_30.2: type = ptr_type @.1.%U.loc13_6.2 (%U.2) [symbolic = %ptr.loc13_30.2 (constants.%ptr.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @.1.%ptr.loc13_30.2 (%ptr.2) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%U.param_patt: type, %T.param_patt: type) -> @.1.%ptr.loc13_30.2 (%ptr.2) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/function/generic/resolve_used.carbon b/toolchain/check/testdata/function/generic/resolve_used.carbon index b2e58751184e..51b5a86e01e5 100644 --- a/toolchain/check/testdata/function/generic/resolve_used.carbon +++ b/toolchain/check/testdata/function/generic/resolve_used.carbon @@ -40,6 +40,7 @@ fn CallNegative() { // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] // CHECK:STDOUT: %iN: type = int_type signed, %N [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %iN [symbolic] // CHECK:STDOUT: %CallNegative.type: type = fn_type @CallNegative [template] // CHECK:STDOUT: %CallNegative: %CallNegative.type = struct_value () [template] // CHECK:STDOUT: %int_0: Core.IntLiteral = int_value 0 [template] @@ -85,6 +86,7 @@ fn CallNegative() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %iN: type = int_type signed, %N.loc4_19.2 [symbolic = %iN (constants.%iN)] +// CHECK:STDOUT: %require_complete: = require_complete_type @ErrorIfNIsZero.%iN (%iN) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%N.param_patt: Core.IntLiteral) { // CHECK:STDOUT: !entry: @@ -120,5 +122,6 @@ fn CallNegative() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %iN => +// CHECK:STDOUT: %require_complete => // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/function/generic/return_slot.carbon b/toolchain/check/testdata/function/generic/return_slot.carbon index 2f6091be4107..ec26c1c08568 100644 --- a/toolchain/check/testdata/function/generic/return_slot.carbon +++ b/toolchain/check/testdata/function/generic/return_slot.carbon @@ -33,6 +33,7 @@ fn G() { // CHECK:STDOUT: %Make.1: %Make.type.1 = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Make.specific_fn.1: = specific_function %Make.1, @Make(%T) [symbolic] // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] @@ -58,6 +59,8 @@ fn G() { // CHECK:STDOUT: %Make.type.4: type = fn_type @Make, @Wrap(%C) [template] // CHECK:STDOUT: %Make.4: %Make.type.4 = struct_value () [template] // CHECK:STDOUT: %Make.specific_fn.4: = specific_function %Make.4, @Make(%C) [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %i32 [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %empty_tuple.type [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -133,6 +136,7 @@ fn G() { // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Make.%T (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %Make.type: type = fn_type @Make, @Wrap(%T) [symbolic = %Make.type (constants.%Make.type.1)] // CHECK:STDOUT: %Make: @Make.%Make.type (%Make.type.1) = struct_value () [symbolic = %Make (constants.%Make.1)] // CHECK:STDOUT: %Make.specific_fn.loc12_27.2: = specific_function %Make, @Make(%T) [symbolic = %Make.specific_fn.loc12_27.2 (constants.%Make.specific_fn.1)] @@ -209,6 +213,7 @@ fn G() { // CHECK:STDOUT: %T => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %Make.type => constants.%Make.type.1 // CHECK:STDOUT: %Make => constants.%Make.1 // CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.1 @@ -241,6 +246,7 @@ fn G() { // CHECK:STDOUT: %T => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.3 // CHECK:STDOUT: %Make.type => constants.%Make.type.2 // CHECK:STDOUT: %Make => constants.%Make.2 // CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.2 @@ -259,6 +265,7 @@ fn G() { // CHECK:STDOUT: %T => constants.%empty_tuple.type // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.4 // CHECK:STDOUT: %Make.type => constants.%Make.type.3 // CHECK:STDOUT: %Make => constants.%Make.3 // CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.3 @@ -277,6 +284,7 @@ fn G() { // CHECK:STDOUT: %T => constants.%C // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Make.type => constants.%Make.type.4 // CHECK:STDOUT: %Make => constants.%Make.4 // CHECK:STDOUT: %Make.specific_fn.loc12_27.2 => constants.%Make.specific_fn.4 diff --git a/toolchain/check/testdata/function/generic/undefined.carbon b/toolchain/check/testdata/function/generic/undefined.carbon index 5d70a16d3fdb..304a8bf829dc 100644 --- a/toolchain/check/testdata/function/generic/undefined.carbon +++ b/toolchain/check/testdata/function/generic/undefined.carbon @@ -57,6 +57,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %Defined.type: type = fn_type @Defined [template] // CHECK:STDOUT: %Defined: %Defined.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -72,6 +73,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.7(%int_32) [template] // CHECK:STDOUT: %int_0.2: %i32 = int_value 0 [template] // CHECK:STDOUT: %Defined.specific_fn: = specific_function %Defined, @Defined(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -125,6 +127,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %T.patt.loc4_12.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4_12.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Defined.%T.loc4_12.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: @Defined.%T.loc4_12.2 (%T)) -> @Defined.%T.loc4_12.2 (%T) { // CHECK:STDOUT: !entry: @@ -164,6 +167,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %T.patt.loc4_12.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- call_defined_late.carbon @@ -188,6 +192,8 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %Convert.specific_fn: = specific_function %Convert.bound, @Convert.7(%int_32) [template] // CHECK:STDOUT: %int_0.2: %i32 = int_value 0 [template] // CHECK:STDOUT: %Defined.specific_fn: = specific_function %Defined, @Defined(%i32) [template] +// CHECK:STDOUT: %require_complete.7: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -258,6 +264,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %T.patt.loc4: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc4 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Defined.%T.loc4_12.2 (%T) [symbolic = %require_complete (constants.%require_complete.7)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%x.param_patt: %T) -> %T { // CHECK:STDOUT: !entry: @@ -297,6 +304,7 @@ fn CallUndefined() -> i32 { // CHECK:STDOUT: %T.patt.loc4 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- fail_call_undefined.carbon diff --git a/toolchain/check/testdata/generic/complete_type.carbon b/toolchain/check/testdata/generic/complete_type.carbon new file mode 100644 index 000000000000..15cc795cfc94 --- /dev/null +++ b/toolchain/check/testdata/generic/complete_type.carbon @@ -0,0 +1,359 @@ +// 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/generic/complete_type.carbon +// TIP: To dump output, run: +// TIP: bazel run //toolchain/testing:file_test -- --dump_output --file_tests=toolchain/check/testdata/generic/complete_type.carbon + +// --- fail_incomplete_in_class.carbon + +library "[[@TEST_NAME]]"; + +class B; + +class A(T:! type) { + // CHECK:STDERR: fail_incomplete_in_class.carbon:[[@LINE+7]]:10: error: `T` evaluates to incomplete type `B` [IncompleteTypeInMonomorphization] + // CHECK:STDERR: var v: T; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_incomplete_in_class.carbon:[[@LINE-6]]:1: note: class was forward declared here [ClassForwardDeclaredHere] + // CHECK:STDERR: class B; + // CHECK:STDERR: ^~~~~~~~ + // CHECK:STDERR: + var v: T; +} + +// CHECK:STDERR: fail_incomplete_in_class.carbon:[[@LINE+7]]:6: error: parameter has incomplete type `A(B)` in function definition [IncompleteTypeInFunctionParam] +// CHECK:STDERR: fn F(x: A(B)) {} +// CHECK:STDERR: ^~~~~~~ +// CHECK:STDERR: fail_incomplete_in_class.carbon:[[@LINE-16]]:1: note: class was forward declared here [ClassForwardDeclaredHere] +// CHECK:STDERR: class B; +// CHECK:STDERR: ^~~~~~~~ +// CHECK:STDERR: +fn F(x: A(B)) {} + +class B {} + +// --- incomplete_in_function.carbon + +library "[[@TEST_NAME]]"; + +class B; + +fn F(T:! type) { + var v: T; +} + +// F(B) isn't resolved until the end of the file. +fn G() { F(B); } + +class B {} + +// --- fail_incomplete_in_function_at_eof.carbon + +library "[[@TEST_NAME]]"; + +class B; + +fn F(T:! type) { + // CHECK:STDERR: fail_incomplete_in_function_at_eof.carbon:[[@LINE+6]]:10: error: `T` evaluates to incomplete type `B` [IncompleteTypeInMonomorphization] + // CHECK:STDERR: var v: T; + // CHECK:STDERR: ^ + // CHECK:STDERR: fail_incomplete_in_function_at_eof.carbon:[[@LINE-6]]:1: note: class was forward declared here [ClassForwardDeclaredHere] + // CHECK:STDERR: class B; + // CHECK:STDERR: ^~~~~~~~ + var v: T; +} + +fn G() { F(B); } + +// CHECK:STDOUT: --- fail_incomplete_in_class.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %B: type = class_type @B [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %A.type: type = generic_class_type @A [template] +// CHECK:STDOUT: %A.generic: %A.type = struct_value () [template] +// CHECK:STDOUT: %A.1: type = class_type @A, @A(%T) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %A.elem.1: type = unbound_element_type %A.1, %T [symbolic] +// CHECK:STDOUT: %struct_type.v.1: type = struct_type {.v: %T} [symbolic] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.v.1 [symbolic] +// CHECK:STDOUT: %A.2: type = class_type @A, @A(%B) [template] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %A.elem.2: type = unbound_element_type %A.2, %B [template] +// CHECK:STDOUT: %struct_type.v.2: type = struct_type {.v: %B} [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.v.2 [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [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: .B = %B.decl.loc4 +// CHECK:STDOUT: .A = %A.decl +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %B.decl.loc4: type = class_decl @B [template = constants.%B] {} {} +// CHECK:STDOUT: %A.decl: %A.type = class_decl @A [template = constants.%A.generic] { +// CHECK:STDOUT: %T.patt.loc6_9.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_9.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6_9.1, runtime_param [symbolic = %T.patt.loc6_9.2 (constants.%T.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc6_9.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_9.2 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %x.patt: %A.2 = binding_pattern x +// CHECK:STDOUT: %x.param_patt: %A.2 = value_param_pattern %x.patt, runtime_param0 +// CHECK:STDOUT: } { +// CHECK:STDOUT: %A.ref: %A.type = name_ref A, file.%A.decl [template = constants.%A.generic] +// CHECK:STDOUT: %B.ref: type = name_ref B, file.%B.decl.loc4 [template = constants.%B] +// CHECK:STDOUT: %A: type = class_type @A, @A(constants.%B) [template = constants.%A.2] +// CHECK:STDOUT: %x.param: %A.2 = value_param runtime_param0 +// CHECK:STDOUT: %x: %A.2 = bind_name x, %x.param +// CHECK:STDOUT: } +// CHECK:STDOUT: %B.decl.loc26: type = class_decl @B [template = constants.%B] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @B { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%B +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic class @A(%T.loc6_9.1: type) { +// CHECK:STDOUT: %T.loc6_9.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_9.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc6_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_9.2 (constants.%T.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @A.%T.loc6_9.2 (%T) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: %A: type = class_type @A, @A(%T.loc6_9.2) [symbolic = %A (constants.%A.1)] +// CHECK:STDOUT: %A.elem: type = unbound_element_type @A.%A (%A.1), @A.%T.loc6_9.2 (%T) [symbolic = %A.elem (constants.%A.elem.1)] +// CHECK:STDOUT: %struct_type.v: type = struct_type {.v: @A.%T.loc6_9.2 (%T)} [symbolic = %struct_type.v (constants.%struct_type.v.1)] +// CHECK:STDOUT: %complete_type.loc15_1.2: = complete_type_witness @A.%struct_type.v (%struct_type.v.1) [symbolic = %complete_type.loc15_1.2 (constants.%complete_type.1)] +// CHECK:STDOUT: +// CHECK:STDOUT: class { +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc6_9.1 [symbolic = %T.loc6_9.2 (constants.%T)] +// CHECK:STDOUT: %.loc14: @A.%A.elem (%A.elem.1) = field_decl v, element0 [template] +// CHECK:STDOUT: %complete_type.loc15_1.1: = complete_type_witness %struct_type.v.1 [symbolic = %complete_type.loc15_1.2 (constants.%complete_type.1)] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%A.1 +// CHECK:STDOUT: .v = %.loc14 +// CHECK:STDOUT: complete_type_witness = %complete_type.loc15_1.1 +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @F(%x.param_patt: %A.2) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @A(constants.%T) { +// CHECK:STDOUT: %T.loc6_9.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_9.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @A(%T.loc6_9.2) { +// CHECK:STDOUT: %T.loc6_9.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_9.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @A(constants.%B) { +// CHECK:STDOUT: %T.loc6_9.2 => constants.%B +// CHECK:STDOUT: %T.patt.loc6_9.2 => constants.%B +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => +// CHECK:STDOUT: %A => constants.%A.2 +// CHECK:STDOUT: %A.elem => constants.%A.elem.2 +// CHECK:STDOUT: %struct_type.v => constants.%struct_type.v.2 +// CHECK:STDOUT: %complete_type.loc15_1.2 => constants.%complete_type.2 +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- incomplete_in_function.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %B: type = class_type @B [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%B) [template] +// CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [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: .B = %B.decl.loc4 +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %B.decl.loc4: type = class_decl @B [template = constants.%B] {} {} +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %T.patt.loc6_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6_6.1, runtime_param [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc6_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {} +// CHECK:STDOUT: %B.decl.loc13: type = class_decl @B [template = constants.%B] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @B { +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template = constants.%complete_type] +// CHECK:STDOUT: +// CHECK:STDOUT: !members: +// CHECK:STDOUT: .Self = constants.%B +// CHECK:STDOUT: complete_type_witness = %complete_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%T.loc6_6.1: type) { +// CHECK:STDOUT: %T.loc6_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc6_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc6_6.1 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %v.var: ref @F.%T.loc6_6.2 (%T) = var v +// CHECK:STDOUT: %v: ref @F.%T.loc6_6.2 (%T) = bind_name v, %v.var +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] +// CHECK:STDOUT: %B.ref: type = name_ref B, file.%B.decl.loc4 [template = constants.%B] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%B) [template = constants.%F.specific_fn] +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%T) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%B) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%B +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%B +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: --- fail_incomplete_in_function_at_eof.carbon +// CHECK:STDOUT: +// CHECK:STDOUT: constants { +// CHECK:STDOUT: %B: type = class_type @B [template] +// CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic] +// CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] +// CHECK:STDOUT: %F.type: type = fn_type @F [template] +// CHECK:STDOUT: %empty_tuple.type: type = tuple_type () [template] +// CHECK:STDOUT: %F: %F.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] +// CHECK:STDOUT: %G.type: type = fn_type @G [template] +// CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F, @F(%B) [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: .B = %B.decl +// CHECK:STDOUT: .F = %F.decl +// CHECK:STDOUT: .G = %G.decl +// CHECK:STDOUT: } +// CHECK:STDOUT: %Core.import = import Core +// CHECK:STDOUT: %B.decl: type = class_decl @B [template = constants.%B] {} {} +// CHECK:STDOUT: %F.decl: %F.type = fn_decl @F [template = constants.%F] { +// CHECK:STDOUT: %T.patt.loc6_6.1: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: %T.param_patt: type = value_param_pattern %T.patt.loc6_6.1, runtime_param [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: } { +// CHECK:STDOUT: %T.param: type = value_param runtime_param +// CHECK:STDOUT: %T.loc6_6.1: type = bind_symbolic_name T, 0, %T.param [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: } +// CHECK:STDOUT: %G.decl: %G.type = fn_decl @G [template = constants.%G] {} {} +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: class @B; +// CHECK:STDOUT: +// CHECK:STDOUT: generic fn @F(%T.loc6_6.1: type) { +// CHECK:STDOUT: %T.loc6_6.2: type = bind_symbolic_name T, 0 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %T.patt.loc6_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc6_6.2 (constants.%T.patt)] +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T.loc6_6.2 (%T) [symbolic = %require_complete (constants.%require_complete)] +// CHECK:STDOUT: +// CHECK:STDOUT: fn(%T.param_patt: type) { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %T.ref: type = name_ref T, %T.loc6_6.1 [symbolic = %T.loc6_6.2 (constants.%T)] +// CHECK:STDOUT: %v.var: ref @F.%T.loc6_6.2 (%T) = var v +// CHECK:STDOUT: %v: ref @F.%T.loc6_6.2 (%T) = bind_name v, %v.var +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: fn @G() { +// CHECK:STDOUT: !entry: +// CHECK:STDOUT: %F.ref: %F.type = name_ref F, file.%F.decl [template = constants.%F] +// CHECK:STDOUT: %B.ref: type = name_ref B, file.%B.decl [template = constants.%B] +// CHECK:STDOUT: %F.specific_fn: = specific_function %F.ref, @F(constants.%B) [template = constants.%F.specific_fn] +// CHECK:STDOUT: %F.call: init %empty_tuple.type = call %F.specific_fn() +// CHECK:STDOUT: return +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%T) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%T +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%T +// CHECK:STDOUT: } +// CHECK:STDOUT: +// CHECK:STDOUT: specific @F(constants.%B) { +// CHECK:STDOUT: %T.loc6_6.2 => constants.%B +// CHECK:STDOUT: %T.patt.loc6_6.2 => constants.%B +// CHECK:STDOUT: +// CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => +// CHECK:STDOUT: } +// CHECK:STDOUT: diff --git a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon index 78e02a33a3b4..f9286638026d 100644 --- a/toolchain/check/testdata/if_expr/fail_not_in_function.carbon +++ b/toolchain/check/testdata/if_expr/fail_not_in_function.carbon @@ -78,8 +78,8 @@ class C { // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C -// CHECK:STDOUT: .n = .inst369.loc37_8 -// CHECK:STDOUT: complete_type_witness = .inst371.loc38_1 +// CHECK:STDOUT: .n = .inst387.loc37_8 +// CHECK:STDOUT: complete_type_witness = .inst389.loc38_1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @__global_init() { diff --git a/toolchain/check/testdata/impl/extend_impl_generic.carbon b/toolchain/check/testdata/impl/extend_impl_generic.carbon index adf77c8c2f20..121ab9fe35c0 100644 --- a/toolchain/check/testdata/impl/extend_impl_generic.carbon +++ b/toolchain/check/testdata/impl/extend_impl_generic.carbon @@ -317,6 +317,7 @@ class X(U:! type) { // CHECK:STDOUT: %X.generic: %X.type = struct_value () [template] // CHECK:STDOUT: %X: type = class_type @X, @X(%U) [symbolic] // CHECK:STDOUT: %I.type.3: type = facet_type <@I, @I(%U)> [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %I.type.3 [symbolic] // CHECK:STDOUT: %F.type.2: type = fn_type @F.1, @I(%U) [symbolic] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] // CHECK:STDOUT: %F.assoc_type.2: type = assoc_entity_type %I.type.3, %F.type.2 [symbolic] @@ -327,6 +328,8 @@ class X(U:! type) { // CHECK:STDOUT: %interface: = interface_witness (%F.3) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %X [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %U [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -406,6 +409,7 @@ class X(U:! type) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type: type = fn_type @F.2, @impl(%U) [symbolic = %F.type (constants.%F.type.3)] // CHECK:STDOUT: %F: @impl.%F.type (%F.type.3) = struct_value () [symbolic = %F (constants.%F.3)] +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.%I.type.loc9_21.2 (%I.type.3) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %interface.loc9_23.2: = interface_witness (%F) [symbolic = %interface.loc9_23.2 (constants.%interface)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %Self.ref as %I.type.loc9_21.1 { @@ -437,6 +441,7 @@ class X(U:! type) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %I.type: type = facet_type <@I, @I(%U.loc8_9.2)> [symbolic = %I.type (constants.%I.type.3)] +// CHECK:STDOUT: %require_complete: = require_complete_type @X.%I.type (%I.type.3) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: class { // CHECK:STDOUT: impl_decl @impl [template] {} { @@ -467,8 +472,12 @@ class X(U:! type) { // CHECK:STDOUT: generic fn @F.2(@X.%U.loc8_9.1: type) { // CHECK:STDOUT: %U: type = bind_symbolic_name U, 0 [symbolic = %U (constants.%U)] // CHECK:STDOUT: %X: type = class_type @X, @X(%U) [symbolic = %X (constants.%X)] +// CHECK:STDOUT: %I.type: type = facet_type <@I, @I(%U)> [symbolic = %I.type (constants.%I.type.3)] +// CHECK:STDOUT: %require_complete.loc10_25: = require_complete_type @F.2.%I.type (%I.type.3) [symbolic = %require_complete.loc10_25 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc10_14: = require_complete_type @F.2.%X (%X) [symbolic = %require_complete.loc10_14 (constants.%require_complete.2)] +// CHECK:STDOUT: %require_complete.loc10_23: = require_complete_type @F.2.%U (%U) [symbolic = %require_complete.loc10_23 (constants.%require_complete.3)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @F.2.%X (%X)](%t.param_patt: @F.2.%U (%U)) { // CHECK:STDOUT: !entry: @@ -504,6 +513,7 @@ class X(U:! type) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %I.type => constants.%I.type.3 +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I(constants.%U) { @@ -537,6 +547,7 @@ class X(U:! type) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.3 // CHECK:STDOUT: %F => constants.%F.3 +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %interface.loc9_23.2 => constants.%interface // CHECK:STDOUT: } // CHECK:STDOUT: @@ -545,9 +556,16 @@ class X(U:! type) { // CHECK:STDOUT: %U.patt.loc8_9.2 => constants.%U // CHECK:STDOUT: } // CHECK:STDOUT: +// CHECK:STDOUT: specific @I(@F.2.%U) { +// CHECK:STDOUT: %T.loc4_13.2 => constants.%U +// CHECK:STDOUT: %T.patt.loc4_13.2 => constants.%U +// CHECK:STDOUT: } +// CHECK:STDOUT: // CHECK:STDOUT: specific @F.2(constants.%U) { // CHECK:STDOUT: %U => constants.%U // CHECK:STDOUT: %X => constants.%X +// CHECK:STDOUT: %I.type => constants.%I.type.3 +// CHECK:STDOUT: %require_complete.loc10_25 => constants.%require_complete.1 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @F.1(constants.%U, constants.%I.facet) { diff --git a/toolchain/check/testdata/impl/fail_extend_impl_forall.carbon b/toolchain/check/testdata/impl/fail_extend_impl_forall.carbon index ef38d9997ca7..6b8b2a052db4 100644 --- a/toolchain/check/testdata/impl/fail_extend_impl_forall.carbon +++ b/toolchain/check/testdata/impl/fail_extend_impl_forall.carbon @@ -37,10 +37,12 @@ class C { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %F.type.2: type = fn_type @F.2, @impl(%T) [symbolic] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %GenericInterface.type.2 [symbolic] // CHECK:STDOUT: %GenericInterface.facet: %GenericInterface.type.2 = facet_value %C, %C [symbolic] // CHECK:STDOUT: %interface: = interface_witness (%F.2) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %T [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -106,6 +108,7 @@ class C { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type: type = fn_type @F.2, @impl(%T.loc19_23.2) [symbolic = %F.type (constants.%F.type.2)] // CHECK:STDOUT: %F: @impl.%F.type (%F.type.2) = struct_value () [symbolic = %F (constants.%F.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.%GenericInterface.type.loc19_54.2 (%GenericInterface.type.2) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %interface.loc19_56.2: = interface_witness (%F) [symbolic = %interface.loc19_56.2 (constants.%interface)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %Self.ref as %GenericInterface.type.loc19_54.1 { @@ -156,6 +159,7 @@ class C { // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.2.%T (%T) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%x.param_patt: @F.2.%T (%T)) { // CHECK:STDOUT: !entry: @@ -198,6 +202,7 @@ class C { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.2 // CHECK:STDOUT: %F => constants.%F.2 +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %interface.loc19_56.2 => constants.%interface // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/lookup/generic.carbon b/toolchain/check/testdata/impl/lookup/generic.carbon index e16e3cfa1d9d..470756403971 100644 --- a/toolchain/check/testdata/impl/lookup/generic.carbon +++ b/toolchain/check/testdata/impl/lookup/generic.carbon @@ -287,6 +287,7 @@ fn G(x: A) { // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] // CHECK:STDOUT: %HasF.facet: %HasF.type = facet_value %T, %T [symbolic] // CHECK:STDOUT: %interface.1: = interface_witness (%F.2) [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] @@ -294,6 +295,7 @@ fn G(x: A) { // CHECK:STDOUT: %F.3: %F.type.3 = struct_value () [template] // CHECK:STDOUT: %interface.2: = interface_witness (%F.3) [template] // CHECK:STDOUT: %empty_struct: %empty_struct_type = struct_value () [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -406,6 +408,7 @@ fn G(x: A) { // CHECK:STDOUT: %T: type = bind_symbolic_name T, 0 [symbolic = %T (constants.%T)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @F.2.%T (%T) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @F.2.%T (%T)]() -> @F.2.%T (%T) { // CHECK:STDOUT: !entry: @@ -473,6 +476,7 @@ fn G(x: A) { // CHECK:STDOUT: %T => constants.%empty_struct_type // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: --- deduced_type_argument.carbon @@ -695,6 +699,7 @@ fn G(x: A) { // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %F.type.2: type = fn_type @F.2, @impl(%T) [symbolic] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %HasF.type.2 [symbolic] // CHECK:STDOUT: %HasF.facet: %HasF.type.2 = facet_value %empty_struct_type, %empty_struct_type [symbolic] // CHECK:STDOUT: %interface.1: = interface_witness (%F.2) [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] @@ -706,6 +711,7 @@ fn G(x: A) { // CHECK:STDOUT: %assoc0.2: %F.assoc_type.2 = assoc_entity element0, @HasF.%F.decl [template] // CHECK:STDOUT: %F.type.4: type = fn_type @F.2, @impl(%empty_struct_type) [template] // CHECK:STDOUT: %F.4: %F.type.4 = struct_value () [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %HasF.type.3 [template] // CHECK:STDOUT: %interface.2: = interface_witness (%F.4) [template] // CHECK:STDOUT: %F.specific_fn: = specific_function %F.4, @F.2(%empty_struct_type) [template] // CHECK:STDOUT: } @@ -786,6 +792,7 @@ fn G(x: A) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type: type = fn_type @F.2, @impl(%T.loc8_14.2) [symbolic = %F.type (constants.%F.type.2)] // CHECK:STDOUT: %F: @impl.%F.type (%F.type.2) = struct_value () [symbolic = %F (constants.%F.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.%HasF.type.loc8_36.2 (%HasF.type.2) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %interface.loc8_38.2: = interface_witness (%F) [symbolic = %interface.loc8_38.2 (constants.%interface.1)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %.loc8_25.2 as %HasF.type.loc8_36.1 { @@ -860,6 +867,7 @@ fn G(x: A) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.2 // CHECK:STDOUT: %F => constants.%F.2 +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %interface.loc8_38.2 => constants.%interface.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -894,6 +902,7 @@ fn G(x: A) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.4 // CHECK:STDOUT: %F => constants.%F.4 +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: %interface.loc8_38.2 => constants.%interface.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -1056,6 +1065,7 @@ fn G(x: A) { // CHECK:STDOUT: %assoc0.1: %F.assoc_type.1 = assoc_entity element0, @HasF.%F.decl [symbolic] // CHECK:STDOUT: %F.type.2: type = fn_type @F.2, @impl(%T) [symbolic] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %HasF.type.2 [symbolic] // CHECK:STDOUT: %HasF.facet: %HasF.type.2 = facet_value %T, %T [symbolic] // CHECK:STDOUT: %interface: = interface_witness (%F.2) [symbolic] // CHECK:STDOUT: %A: type = class_type @A [template] @@ -1149,6 +1159,7 @@ fn G(x: A) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type: type = fn_type @F.2, @impl(%T.loc8_14.2) [symbolic = %F.type (constants.%F.type.2)] // CHECK:STDOUT: %F: @impl.%F.type (%F.type.2) = struct_value () [symbolic = %F (constants.%F.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.%HasF.type.loc8_35.2 (%HasF.type.2) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: %interface.loc8_37.2: = interface_witness (%F) [symbolic = %interface.loc8_37.2 (constants.%interface)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %T.ref.loc8_24 as %HasF.type.loc8_35.1 { @@ -1235,6 +1246,7 @@ fn G(x: A) { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.2 // CHECK:STDOUT: %F => constants.%F.2 +// CHECK:STDOUT: %require_complete => constants.%require_complete // CHECK:STDOUT: %interface.loc8_37.2 => constants.%interface // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/lookup/no_prelude/impl_forall.carbon b/toolchain/check/testdata/impl/lookup/no_prelude/impl_forall.carbon index d2c5aaca94fe..72351de2c7dc 100644 --- a/toolchain/check/testdata/impl/lookup/no_prelude/impl_forall.carbon +++ b/toolchain/check/testdata/impl/lookup/no_prelude/impl_forall.carbon @@ -40,6 +40,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A.type: type = generic_class_type @A [template] // CHECK:STDOUT: %A.generic: %A.type = struct_value () [template] // CHECK:STDOUT: %A.1: type = class_type @A, @A(%T) [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %A.elem.1: type = unbound_element_type %A.1, %T [symbolic] // CHECK:STDOUT: %struct_type.n.1: type = struct_type {.n: %T} [symbolic] // CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.n.1 [symbolic] @@ -60,24 +61,30 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %I.type.3: type = facet_type <@I, @I(%V)> [symbolic] // CHECK:STDOUT: %F.type.2: type = fn_type @F.2, @impl(%V) [symbolic] // CHECK:STDOUT: %F.2: %F.type.2 = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %I.type.3 [symbolic] // CHECK:STDOUT: %F.type.3: type = fn_type @F.1, @I(%V) [symbolic] // CHECK:STDOUT: %F.3: %F.type.3 = struct_value () [symbolic] // CHECK:STDOUT: %F.assoc_type.2: type = assoc_entity_type %I.type.3, %F.type.3 [symbolic] // CHECK:STDOUT: %assoc0.2: %F.assoc_type.2 = assoc_entity element0, @I.%F.decl [symbolic] // CHECK:STDOUT: %I.facet: %I.type.2 = facet_value %A.2, %A.2 [symbolic] // CHECK:STDOUT: %interface.1: = interface_witness (%F.2) [symbolic] +// CHECK:STDOUT: %require_complete.3: = require_complete_type %V [symbolic] // CHECK:STDOUT: %A.elem.2: type = unbound_element_type %A.2, %V [symbolic] // CHECK:STDOUT: %struct_type.n.2: type = struct_type {.n: %V} [symbolic] // CHECK:STDOUT: %complete_type.2: = complete_type_witness %struct_type.n.2 [symbolic] +// CHECK:STDOUT: %require_complete.4: = require_complete_type %A.2 [symbolic] // CHECK:STDOUT: %W: type = bind_symbolic_name W, 0 [symbolic] // CHECK:STDOUT: %W.patt: type = symbolic_binding_pattern W, 0 [symbolic] // CHECK:STDOUT: %A.3: type = class_type @A, @A(%W) [symbolic] // CHECK:STDOUT: %TestGeneric.type: type = fn_type @TestGeneric [template] // CHECK:STDOUT: %TestGeneric: %TestGeneric.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.5: = require_complete_type %W [symbolic] // CHECK:STDOUT: %A.elem.3: type = unbound_element_type %A.3, %W [symbolic] // CHECK:STDOUT: %struct_type.n.3: type = struct_type {.n: %W} [symbolic] // CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.n.3 [symbolic] +// CHECK:STDOUT: %require_complete.6: = require_complete_type %A.3 [symbolic] // CHECK:STDOUT: %I.type.4: type = facet_type <@I, @I(%W)> [symbolic] +// CHECK:STDOUT: %require_complete.7: = require_complete_type %I.type.4 [symbolic] // CHECK:STDOUT: %F.type.4: type = fn_type @F.1, @I(%W) [symbolic] // CHECK:STDOUT: %F.4: %F.type.4 = struct_value () [symbolic] // CHECK:STDOUT: %F.assoc_type.3: type = assoc_entity_type %I.type.4, %F.type.4 [symbolic] @@ -89,9 +96,10 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A.4: type = class_type @A, @A(%empty_struct_type) [template] // CHECK:STDOUT: %TestSpecific.type: type = fn_type @TestSpecific [template] // CHECK:STDOUT: %TestSpecific: %TestSpecific.type = struct_value () [template] +// CHECK:STDOUT: %complete_type.4: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %A.elem.4: type = unbound_element_type %A.4, %empty_struct_type [template] // CHECK:STDOUT: %struct_type.n.4: type = struct_type {.n: %empty_struct_type} [template] -// CHECK:STDOUT: %complete_type.4: = complete_type_witness %struct_type.n.4 [template] +// CHECK:STDOUT: %complete_type.5: = complete_type_witness %struct_type.n.4 [template] // CHECK:STDOUT: %I.type.5: type = facet_type <@I, @I(%empty_struct_type)> [template] // CHECK:STDOUT: %F.type.6: type = fn_type @F.1, @I(%empty_struct_type) [template] // CHECK:STDOUT: %F.6: %F.type.6 = struct_value () [template] @@ -99,6 +107,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %assoc0.4: %F.assoc_type.4 = assoc_entity element0, @I.%F.decl [template] // CHECK:STDOUT: %F.type.7: type = fn_type @F.2, @impl(%empty_struct_type) [template] // CHECK:STDOUT: %F.7: %F.type.7 = struct_value () [template] +// CHECK:STDOUT: %complete_type.6: = complete_type_witness %I.type.5 [template] // CHECK:STDOUT: %interface.3: = interface_witness (%F.7) [template] // CHECK:STDOUT: %empty_struct: %empty_struct_type = struct_value () [template] // CHECK:STDOUT: } @@ -223,6 +232,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type: type = fn_type @F.2, @impl(%V.loc10_14.2) [symbolic = %F.type (constants.%F.type.2)] // CHECK:STDOUT: %F: @impl.%F.type (%F.type.2) = struct_value () [symbolic = %F (constants.%F.2)] +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.%I.type.loc10_35.2 (%I.type.3) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: %interface.loc10_37.2: = interface_witness (%F) [symbolic = %interface.loc10_37.2 (constants.%interface.1)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %A.loc10_27.1 as %I.type.loc10_35.1 { @@ -252,6 +262,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %T.patt.loc2_9.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc2_9.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @A.%T.loc2_9.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %A: type = class_type @A, @A(%T.loc2_9.2) [symbolic = %A (constants.%A.1)] // CHECK:STDOUT: %A.elem: type = unbound_element_type @A.%A (%A.1), @A.%T.loc2_9.2 (%T) [symbolic = %A.elem (constants.%A.elem.1)] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: @A.%T.loc2_9.2 (%T)} [symbolic = %struct_type.n (constants.%struct_type.n.1)] @@ -283,6 +294,8 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A: type = class_type @A, @A(%V) [symbolic = %A (constants.%A.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc11_22: = require_complete_type @F.2.%V (%V) [symbolic = %require_complete.loc11_22 (constants.%require_complete.3)] +// CHECK:STDOUT: %require_complete.loc11_12: = require_complete_type @F.2.%A (%A.2) [symbolic = %require_complete.loc11_12 (constants.%require_complete.4)] // CHECK:STDOUT: %A.elem: type = unbound_element_type @F.2.%A (%A.2), @F.2.%V (%V) [symbolic = %A.elem (constants.%A.elem.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @F.2.%A (%A.2)]() -> @F.2.%V (%V) { @@ -301,7 +314,10 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A.loc16_32.2: type = class_type @A, @A(%W.loc16_16.2) [symbolic = %A.loc16_32.2 (constants.%A.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc16_35: = require_complete_type @TestGeneric.%W.loc16_16.2 (%W) [symbolic = %require_complete.loc16_35 (constants.%require_complete.5)] +// CHECK:STDOUT: %require_complete.loc16_27: = require_complete_type @TestGeneric.%A.loc16_32.2 (%A.3) [symbolic = %require_complete.loc16_27 (constants.%require_complete.6)] // CHECK:STDOUT: %I.type.loc17_16.2: type = facet_type <@I, @I(%W.loc16_16.2)> [symbolic = %I.type.loc17_16.2 (constants.%I.type.4)] +// CHECK:STDOUT: %require_complete.loc17: = require_complete_type @TestGeneric.%I.type.loc17_16.2 (%I.type.4) [symbolic = %require_complete.loc17 (constants.%require_complete.7)] // CHECK:STDOUT: %F.type.loc17_17: type = fn_type @F.1, @I(%W.loc16_16.2) [symbolic = %F.type.loc17_17 (constants.%F.type.4)] // CHECK:STDOUT: %F.assoc_type: type = assoc_entity_type @TestGeneric.%I.type.loc17_16.2 (%I.type.4), @TestGeneric.%F.type.loc17_17 (%F.type.4) [symbolic = %F.assoc_type (constants.%F.assoc_type.3)] // CHECK:STDOUT: %assoc0: @TestGeneric.%F.assoc_type (%F.assoc_type.3) = assoc_entity element0, @I.%F.decl [symbolic = %assoc0 (constants.%assoc0.3)] @@ -383,6 +399,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %T.patt.loc2_9.2 => constants.%V // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.3 // CHECK:STDOUT: %A => constants.%A.2 // CHECK:STDOUT: %A.elem => constants.%A.elem.2 // CHECK:STDOUT: %struct_type.n => constants.%struct_type.n.2 @@ -421,6 +438,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.2 // CHECK:STDOUT: %F => constants.%F.2 +// CHECK:STDOUT: %require_complete => constants.%require_complete.2 // CHECK:STDOUT: %interface.loc10_37.2 => constants.%interface.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -453,6 +471,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %T.patt.loc2_9.2 => constants.%W // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.5 // CHECK:STDOUT: %A => constants.%A.3 // CHECK:STDOUT: %A.elem => constants.%A.elem.3 // CHECK:STDOUT: %struct_type.n => constants.%struct_type.n.3 @@ -492,6 +511,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.5 // CHECK:STDOUT: %F => constants.%F.5 +// CHECK:STDOUT: %require_complete => constants.%require_complete.7 // CHECK:STDOUT: %interface.loc10_37.2 => constants.%interface.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -500,6 +520,8 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A => constants.%A.3 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc11_22 => constants.%require_complete.5 +// CHECK:STDOUT: %require_complete.loc11_12 => constants.%require_complete.6 // CHECK:STDOUT: %A.elem => constants.%A.elem.3 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -520,10 +542,11 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %T.patt.loc2_9.2 => constants.%empty_struct_type // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.4 // CHECK:STDOUT: %A => constants.%A.4 // CHECK:STDOUT: %A.elem => constants.%A.elem.4 // CHECK:STDOUT: %struct_type.n => constants.%struct_type.n.4 -// CHECK:STDOUT: %complete_type.loc4_1.2 => constants.%complete_type.4 +// CHECK:STDOUT: %complete_type.loc4_1.2 => constants.%complete_type.5 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I(constants.%empty_struct_type) { @@ -548,6 +571,7 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %F.type => constants.%F.type.7 // CHECK:STDOUT: %F => constants.%F.7 +// CHECK:STDOUT: %require_complete => constants.%complete_type.6 // CHECK:STDOUT: %interface.loc10_37.2 => constants.%interface.3 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -556,6 +580,8 @@ fn TestSpecific(a: A({})) -> {} { // CHECK:STDOUT: %A => constants.%A.4 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc11_22 => constants.%complete_type.4 +// CHECK:STDOUT: %require_complete.loc11_12 => constants.%complete_type.5 // CHECK:STDOUT: %A.elem => constants.%A.elem.4 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/impl/no_prelude/import_generic.carbon b/toolchain/check/testdata/impl/no_prelude/import_generic.carbon index 6cf5d23d1692..4e8566a2dd1e 100644 --- a/toolchain/check/testdata/impl/no_prelude/import_generic.carbon +++ b/toolchain/check/testdata/impl/no_prelude/import_generic.carbon @@ -51,6 +51,7 @@ impl forall [T:! type] C as I(T*) {} // CHECK:STDOUT: %Self: %I.type.2 = bind_symbolic_name Self, 1 [symbolic] // CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] // CHECK:STDOUT: %I.type.3: type = facet_type <@I, @I(%ptr)> [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %I.type.3 [symbolic] // CHECK:STDOUT: %interface: = interface_witness () [template] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -124,6 +125,7 @@ impl forall [T:! type] C as I(T*) {} // CHECK:STDOUT: %I.type.loc8_33.2: type = facet_type <@I, @I(%ptr.loc8_32.2)> [symbolic = %I.type.loc8_33.2 (constants.%I.type.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.2.%I.type.loc8_33.2 (%I.type.3) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: impl: %C.ref as %I.type.loc8_33.1 { // CHECK:STDOUT: %interface: = interface_witness () [template = constants.%interface] @@ -197,6 +199,8 @@ impl forall [T:! type] C as I(T*) {} // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %ptr: type = ptr_type %T [symbolic] // CHECK:STDOUT: %I.type.3: type = facet_type <@I, @I(%ptr)> [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %I.type.3 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %I.type.2 [symbolic] // CHECK:STDOUT: %interface: = interface_witness () [template] // CHECK:STDOUT: } // CHECK:STDOUT: @@ -251,6 +255,7 @@ impl forall [T:! type] C as I(T*) {} // CHECK:STDOUT: %I.type.1: type = facet_type <@I, @I(%T.1)> [symbolic = %I.type.1 (constants.%I.type.2)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.1.%I.type.1 (%I.type.2) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: impl: imports.%import_ref.6 as imports.%import_ref.7 { // CHECK:STDOUT: %interface: = interface_witness () [template = constants.%interface] @@ -267,6 +272,7 @@ impl forall [T:! type] C as I(T*) {} // CHECK:STDOUT: %I.type: type = facet_type <@I, @I(%ptr)> [symbolic = %I.type (constants.%I.type.3)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @impl.2.%I.type (%I.type.3) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: impl: imports.%import_ref.8 as imports.%import_ref.9 { // CHECK:STDOUT: !members: diff --git a/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon b/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon index 64115b4513ea..ce4ac90f3eab 100644 --- a/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon +++ b/toolchain/check/testdata/interface/fail_todo_define_default_fn_out_of_line.carbon @@ -217,6 +217,8 @@ fn Interface.C.F[self: Self](U:! type, u: U) -> U { return u; } // CHECK:STDOUT: %F: %F.type = struct_value () [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %U [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %C.2 [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -314,6 +316,8 @@ fn Interface.C.F[self: Self](U:! type, u: U) -> U { return u; } // CHECK:STDOUT: %U.patt.loc14: type = symbolic_binding_pattern U, 1 [symbolic = %U.patt.loc14 (constants.%U.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc20_46: = require_complete_type @F.%U.loc14_22.1 (%U) [symbolic = %require_complete.loc20_46 (constants.%require_complete.1)] +// CHECK:STDOUT: %require_complete.loc20_22: = require_complete_type @F.%C (%C.2) [symbolic = %require_complete.loc20_22 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: %C.2](%U.param_patt: type, %u.param_patt: %U) -> %U { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/interface/member_lookup.carbon b/toolchain/check/testdata/interface/member_lookup.carbon index 07e49e82ed63..582c0db0f692 100644 --- a/toolchain/check/testdata/interface/member_lookup.carbon +++ b/toolchain/check/testdata/interface/member_lookup.carbon @@ -56,12 +56,14 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %Interface.generic: %Interface.type.1 = struct_value () [template] // CHECK:STDOUT: %Interface.type.2: type = facet_type <@Interface, @Interface(%T)> [symbolic] // CHECK:STDOUT: %Self: %Interface.type.2 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %assoc_type.1: type = assoc_entity_type %Interface.type.2, %T [symbolic] // CHECK:STDOUT: %assoc0.1: %assoc_type.1 = assoc_entity element0, @Interface.%X [symbolic] // CHECK:STDOUT: %I.1: %Interface.type.2 = bind_symbolic_name I, 1 [symbolic] // CHECK:STDOUT: %I.patt.1: %Interface.type.2 = symbolic_binding_pattern I, 1 [symbolic] // CHECK:STDOUT: %AccessGeneric.type: type = fn_type @AccessGeneric [template] // CHECK:STDOUT: %AccessGeneric: %AccessGeneric.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Interface.type.2 [symbolic] // CHECK:STDOUT: %I.as_wit.1: = facet_access_witness %I.1 [symbolic] // CHECK:STDOUT: %impl.elem0.1: %T = interface_witness_access %I.as_wit.1, element0 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] @@ -73,6 +75,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %I.patt.2: %Interface.type.3 = symbolic_binding_pattern I, 0 [symbolic] // CHECK:STDOUT: %AccessConcrete.type: type = fn_type @AccessConcrete [template] // CHECK:STDOUT: %AccessConcrete: %AccessConcrete.type = struct_value () [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %i32 [template] // CHECK:STDOUT: %assoc_type.2: type = assoc_entity_type %Interface.type.3, %i32 [template] // CHECK:STDOUT: %assoc0.2: %assoc_type.2 = assoc_entity element0, @Interface.%X [template] // CHECK:STDOUT: %I.as_wit.2: = facet_access_witness %I.2 [symbolic] @@ -151,6 +154,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type: type = facet_type <@Interface, @Interface(%T.loc4_21.2)> [symbolic = %Interface.type (constants.%Interface.type.2)] // CHECK:STDOUT: %Self.2: %Interface.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %require_complete: = require_complete_type @Interface.%T.loc4_21.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %assoc_type: type = assoc_entity_type @Interface.%Interface.type (%Interface.type.2), @Interface.%T.loc4_21.2 (%T) [symbolic = %assoc_type (constants.%assoc_type.1)] // CHECK:STDOUT: %assoc0.loc5_12.2: @Interface.%assoc_type (%assoc_type.1) = assoc_entity element0, %X [symbolic = %assoc0.loc5_12.2 (constants.%assoc0.1)] // CHECK:STDOUT: @@ -175,10 +179,12 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %I.patt.loc8_28.2: %Interface.type.2 = symbolic_binding_pattern I, 1 [symbolic = %I.patt.loc8_28.2 (constants.%I.patt.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc9_10: = require_complete_type @AccessGeneric.%Interface.type.loc8_43.2 (%Interface.type.2) [symbolic = %require_complete.loc9_10 (constants.%require_complete.2)] // CHECK:STDOUT: %assoc_type: type = assoc_entity_type @AccessGeneric.%Interface.type.loc8_43.2 (%Interface.type.2), @AccessGeneric.%T.loc8_18.2 (%T) [symbolic = %assoc_type (constants.%assoc_type.1)] // CHECK:STDOUT: %assoc0: @AccessGeneric.%assoc_type (%assoc_type.1) = assoc_entity element0, @Interface.%X [symbolic = %assoc0 (constants.%assoc0.1)] // CHECK:STDOUT: %I.as_wit.loc9_11.2: = facet_access_witness %I.loc8_28.2 [symbolic = %I.as_wit.loc9_11.2 (constants.%I.as_wit.1)] // CHECK:STDOUT: %impl.elem0.loc9_11.2: @AccessGeneric.%T.loc8_18.2 (%T) = interface_witness_access %I.as_wit.loc9_11.2, element0 [symbolic = %impl.elem0.loc9_11.2 (constants.%impl.elem0.1)] +// CHECK:STDOUT: %require_complete.loc9_13: = require_complete_type @AccessGeneric.%T.loc8_18.2 (%T) [symbolic = %require_complete.loc9_13 (constants.%require_complete.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%I.param_patt: @AccessGeneric.%Interface.type.loc8_43.2 (%Interface.type.2)) -> @AccessGeneric.%T.loc8_18.2 (%T) { // CHECK:STDOUT: !entry: @@ -217,6 +223,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type => constants.%Interface.type.2 // CHECK:STDOUT: %Self.2 => constants.%Self +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %assoc_type => constants.%assoc_type.1 // CHECK:STDOUT: %assoc0.loc5_12.2 => constants.%assoc0.1 // CHECK:STDOUT: } @@ -246,6 +253,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type => constants.%Interface.type.3 // CHECK:STDOUT: %Self.2 => constants.%Self +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: %assoc_type => constants.%assoc_type.2 // CHECK:STDOUT: %assoc0.loc5_12.2 => constants.%assoc0.2 // CHECK:STDOUT: } @@ -264,12 +272,14 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %Interface.generic: %Interface.type.1 = struct_value () [template] // CHECK:STDOUT: %Interface.type.2: type = facet_type <@Interface, @Interface(%T)> [symbolic] // CHECK:STDOUT: %Self: %Interface.type.2 = bind_symbolic_name Self, 1 [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %assoc_type.1: type = assoc_entity_type %Interface.type.2, %T [symbolic] // CHECK:STDOUT: %assoc0.1: %assoc_type.1 = assoc_entity element0, @Interface.%X [symbolic] // CHECK:STDOUT: %I.1: %Interface.type.2 = bind_symbolic_name I, 1 [symbolic] // CHECK:STDOUT: %I.patt.1: %Interface.type.2 = symbolic_binding_pattern I, 1 [symbolic] // CHECK:STDOUT: %AccessMissingGeneric.type: type = fn_type @AccessMissingGeneric [template] // CHECK:STDOUT: %AccessMissingGeneric: %AccessMissingGeneric.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Interface.type.2 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -279,6 +289,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %I.patt.2: %Interface.type.3 = symbolic_binding_pattern I, 0 [symbolic] // CHECK:STDOUT: %AccessMissingConcrete.type: type = fn_type @AccessMissingConcrete [template] // CHECK:STDOUT: %AccessMissingConcrete: %AccessMissingConcrete.type = struct_value () [template] +// CHECK:STDOUT: %complete_type: = complete_type_witness %i32 [template] // CHECK:STDOUT: %assoc_type.2: type = assoc_entity_type %Interface.type.3, %i32 [template] // CHECK:STDOUT: %assoc0.2: %assoc_type.2 = assoc_entity element0, @Interface.%X [template] // CHECK:STDOUT: } @@ -355,6 +366,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type: type = facet_type <@Interface, @Interface(%T.loc4_21.2)> [symbolic = %Interface.type (constants.%Interface.type.2)] // CHECK:STDOUT: %Self.2: %Interface.type.2 = bind_symbolic_name Self, 1 [symbolic = %Self.2 (constants.%Self)] +// CHECK:STDOUT: %require_complete: = require_complete_type @Interface.%T.loc4_21.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %assoc_type: type = assoc_entity_type @Interface.%Interface.type (%Interface.type.2), @Interface.%T.loc4_21.2 (%T) [symbolic = %assoc_type (constants.%assoc_type.1)] // CHECK:STDOUT: %assoc0.loc5_12.2: @Interface.%assoc_type (%assoc_type.1) = assoc_entity element0, %X [symbolic = %assoc0.loc5_12.2 (constants.%assoc0.1)] // CHECK:STDOUT: @@ -379,6 +391,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: %I.patt.loc8_35.2: %Interface.type.2 = symbolic_binding_pattern I, 1 [symbolic = %I.patt.loc8_35.2 (constants.%I.patt.1)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @AccessMissingGeneric.%Interface.type.loc8_50.2 (%Interface.type.2) [symbolic = %require_complete (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%T.param_patt: type](%I.param_patt: @AccessMissingGeneric.%Interface.type.loc8_50.2 (%Interface.type.2)) -> @AccessMissingGeneric.%T.loc8_25.2 (%T) { // CHECK:STDOUT: !entry: @@ -409,6 +422,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type => constants.%Interface.type.2 // CHECK:STDOUT: %Self.2 => constants.%Self +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %assoc_type => constants.%assoc_type.1 // CHECK:STDOUT: %assoc0.loc5_12.2 => constants.%assoc0.1 // CHECK:STDOUT: } @@ -438,6 +452,7 @@ fn AccessMissingConcrete(I:! Interface(i32)) -> i32 { // CHECK:STDOUT: !definition: // CHECK:STDOUT: %Interface.type => constants.%Interface.type.3 // CHECK:STDOUT: %Self.2 => constants.%Self +// CHECK:STDOUT: %require_complete => constants.%complete_type // CHECK:STDOUT: %assoc_type => constants.%assoc_type.2 // CHECK:STDOUT: %assoc0.loc5_12.2 => constants.%assoc0.2 // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/interface/no_prelude/as_type_of_type.carbon b/toolchain/check/testdata/interface/no_prelude/as_type_of_type.carbon index d9927135820b..f51912518a12 100644 --- a/toolchain/check/testdata/interface/no_prelude/as_type_of_type.carbon +++ b/toolchain/check/testdata/interface/no_prelude/as_type_of_type.carbon @@ -24,6 +24,7 @@ fn F(T:! Empty) { // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %T.as_type: type = facet_access_type %T [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %T.as_type [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -56,6 +57,7 @@ fn F(T:! Empty) { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %T.as_type.loc14_10.2: type = facet_access_type %T.loc13_6.2 [symbolic = %T.as_type.loc14_10.2 (constants.%T.as_type)] +// CHECK:STDOUT: %require_complete: = require_complete_type @F.%T.as_type.loc14_10.2 (%T.as_type) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: %Empty.type) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/interface/no_prelude/assoc_const_in_generic.carbon b/toolchain/check/testdata/interface/no_prelude/assoc_const_in_generic.carbon index 0417c1947b75..6af8c9486a54 100644 --- a/toolchain/check/testdata/interface/no_prelude/assoc_const_in_generic.carbon +++ b/toolchain/check/testdata/interface/no_prelude/assoc_const_in_generic.carbon @@ -41,14 +41,18 @@ fn H() { // CHECK:STDOUT: %assoc0.1: %F.assoc_type.1 = assoc_entity element0, @I.%F.decl [symbolic] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %I.type.2 [symbolic] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %F.assoc_type.1 [symbolic] // CHECK:STDOUT: %H.type: type = fn_type @H [template] // CHECK:STDOUT: %H: %H.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] // CHECK:STDOUT: %G.specific_fn: = specific_function %G, @G(%empty_struct_type) [template] // CHECK:STDOUT: %I.type.3: type = facet_type <@I, @I(%empty_struct_type)> [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %I.type.3 [template] // CHECK:STDOUT: %F.type.2: type = fn_type @F, @I(%empty_struct_type) [template] // CHECK:STDOUT: %F.assoc_type.2: type = assoc_entity_type %I.type.3, %F.type.2 [template] // CHECK:STDOUT: %assoc0.2: %F.assoc_type.2 = assoc_entity element0, @I.%F.decl [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %F.assoc_type.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -122,9 +126,11 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %I.type.loc19_6.2: type = facet_type <@I, @I(%T.loc15_6.2)> [symbolic = %I.type.loc19_6.2 (constants.%I.type.2)] +// CHECK:STDOUT: %require_complete.loc19_7.1: = require_complete_type @G.%I.type.loc19_6.2 (%I.type.2) [symbolic = %require_complete.loc19_7.1 (constants.%require_complete.1)] // CHECK:STDOUT: %F.type: type = fn_type @F, @I(%T.loc15_6.2) [symbolic = %F.type (constants.%F.type.1)] // CHECK:STDOUT: %F.assoc_type: type = assoc_entity_type @G.%I.type.loc19_6.2 (%I.type.2), @G.%F.type (%F.type.1) [symbolic = %F.assoc_type (constants.%F.assoc_type.1)] // CHECK:STDOUT: %assoc0: @G.%F.assoc_type (%F.assoc_type.1) = assoc_entity element0, @I.%F.decl [symbolic = %assoc0 (constants.%assoc0.1)] +// CHECK:STDOUT: %require_complete.loc19_7.2: = require_complete_type @G.%F.assoc_type (%F.assoc_type.1) [symbolic = %require_complete.loc19_7.2 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) { // CHECK:STDOUT: !entry: @@ -186,9 +192,11 @@ fn H() { // CHECK:STDOUT: // CHECK:STDOUT: !definition: // CHECK:STDOUT: %I.type.loc19_6.2 => constants.%I.type.3 +// CHECK:STDOUT: %require_complete.loc19_7.1 => constants.%complete_type.1 // CHECK:STDOUT: %F.type => constants.%F.type.2 // CHECK:STDOUT: %F.assoc_type => constants.%F.assoc_type.2 // CHECK:STDOUT: %assoc0 => constants.%assoc0.2 +// CHECK:STDOUT: %require_complete.loc19_7.2 => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: specific @I(constants.%empty_struct_type) { diff --git a/toolchain/check/testdata/interface/no_prelude/fail_todo_facet_lookup.carbon b/toolchain/check/testdata/interface/no_prelude/fail_todo_facet_lookup.carbon index ac5cb09c51fb..baca7f01f407 100644 --- a/toolchain/check/testdata/interface/no_prelude/fail_todo_facet_lookup.carbon +++ b/toolchain/check/testdata/interface/no_prelude/fail_todo_facet_lookup.carbon @@ -43,6 +43,7 @@ fn CallFacet(T:! Interface, x: T) { // CHECK:STDOUT: %T.as_type: type = facet_access_type %T [symbolic] // CHECK:STDOUT: %CallFacet.type: type = fn_type @CallFacet [template] // CHECK:STDOUT: %CallFacet: %CallFacet.type = struct_value () [template] +// CHECK:STDOUT: %require_complete: = require_complete_type %T.as_type [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -117,6 +118,7 @@ fn CallFacet(T:! Interface, x: T) { // CHECK:STDOUT: %T.as_type.loc21_32.2: type = facet_access_type %T.loc21_14.2 [symbolic = %T.as_type.loc21_32.2 (constants.%T.as_type)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @CallFacet.%T.as_type.loc21_32.2 (%T.as_type) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: %Interface.type, %x.param_patt: @CallFacet.%T.as_type.loc21_32.2 (%T.as_type)) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/interface/no_prelude/fail_todo_generic_default_fn.carbon b/toolchain/check/testdata/interface/no_prelude/fail_todo_generic_default_fn.carbon index f6caac35fb74..a3db7e48aec5 100644 --- a/toolchain/check/testdata/interface/no_prelude/fail_todo_generic_default_fn.carbon +++ b/toolchain/check/testdata/interface/no_prelude/fail_todo_generic_default_fn.carbon @@ -37,6 +37,7 @@ fn I(T:! type).F[self: Self]() -> Self { return self; } // CHECK:STDOUT: %assoc0: %F.assoc_type = assoc_entity element0, @I.%F.decl [symbolic] // CHECK:STDOUT: %.type: type = fn_type @.1, @I(%T) [symbolic] // CHECK:STDOUT: %.1: %.type = struct_value () [symbolic] +// CHECK:STDOUT: %require_complete: = require_complete_type %Self.as_type [symbolic] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -132,6 +133,7 @@ fn I(T:! type).F[self: Self]() -> Self { return self; } // CHECK:STDOUT: %Self.as_type.loc22_24.2: type = facet_access_type %Self [symbolic = %Self.as_type.loc22_24.2 (constants.%Self.as_type)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @.1.%Self.as_type.loc22_24.2 (%Self.as_type) [symbolic = %require_complete (constants.%require_complete)] // CHECK:STDOUT: // CHECK:STDOUT: fn[%self.param_patt: @.1.%Self.as_type.loc22_24.2 (%Self.as_type)]() -> @.1.%Self.as_type.loc22_24.2 (%Self.as_type) { // CHECK:STDOUT: !entry: diff --git a/toolchain/check/testdata/operators/overloaded/implicit_as.carbon b/toolchain/check/testdata/operators/overloaded/implicit_as.carbon index 3bd2c0270af3..d1e1428fd670 100644 --- a/toolchain/check/testdata/operators/overloaded/implicit_as.carbon +++ b/toolchain/check/testdata/operators/overloaded/implicit_as.carbon @@ -42,7 +42,7 @@ fn Test() { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %X.elem: type = unbound_element_type %X, %i32 [template] // CHECK:STDOUT: %struct_type.n: type = struct_type {.n: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.n [template] // CHECK:STDOUT: %ImplicitAs.type.1: type = generic_interface_type @ImplicitAs [template] // CHECK:STDOUT: %ImplicitAs.generic: %ImplicitAs.type.1 = struct_value () [template] // CHECK:STDOUT: %ImplicitAs.type.3: type = facet_type <@ImplicitAs, @ImplicitAs(%X)> [template] @@ -63,11 +63,13 @@ fn Test() { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %Source.type: type = fn_type @Source [template] // CHECK:STDOUT: %Source: %Source.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %T [symbolic] // CHECK:STDOUT: %Source.specific_fn.1: = specific_function %Source, @Source(%T) [symbolic] // CHECK:STDOUT: %Test.type: type = fn_type @Test [template] // CHECK:STDOUT: %Test: %Test.type = struct_value () [template] // CHECK:STDOUT: %Source.specific_fn.2: = specific_function %Source, @Source(%X) [template] // CHECK:STDOUT: %Source.specific_fn.3: = specific_function %Source, @Source(%i32) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %i32 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -199,7 +201,7 @@ fn Test() { // CHECK:STDOUT: %.loc12_10.1: type = value_of_initializer %int.make_type_signed [template = constants.%i32] // CHECK:STDOUT: %.loc12_10.2: type = converted %int.make_type_signed, %.loc12_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc12_8: %X.elem = field_decl n, element0 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.n [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%X @@ -236,6 +238,7 @@ fn Test() { // CHECK:STDOUT: %T.patt.loc27_11.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc27_11.2 (constants.%T.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete: = require_complete_type @Source.%T.loc27_11.2 (%T) [symbolic = %require_complete (constants.%require_complete.1)] // CHECK:STDOUT: %Source.specific_fn.loc27_35.2: = specific_function constants.%Source, @Source(%T.loc27_11.2) [symbolic = %Source.specific_fn.loc27_35.2 (constants.%Source.specific_fn.1)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type) -> @Source.%T.loc27_11.2 (%T) { @@ -292,6 +295,7 @@ fn Test() { // CHECK:STDOUT: %T.patt.loc27_11.2 => constants.%T // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%require_complete.1 // CHECK:STDOUT: %Source.specific_fn.loc27_35.2 => constants.%Source.specific_fn.1 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -305,6 +309,7 @@ fn Test() { // CHECK:STDOUT: %T.patt.loc27_11.2 => constants.%X // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.1 // CHECK:STDOUT: %Source.specific_fn.loc27_35.2 => constants.%Source.specific_fn.2 // CHECK:STDOUT: } // CHECK:STDOUT: @@ -313,6 +318,7 @@ fn Test() { // CHECK:STDOUT: %T.patt.loc27_11.2 => constants.%i32 // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete => constants.%complete_type.2 // CHECK:STDOUT: %Source.specific_fn.loc27_35.2 => constants.%Source.specific_fn.3 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/check/testdata/return/fail_return_with_returned_var.carbon b/toolchain/check/testdata/return/fail_return_with_returned_var.carbon index c549d4f69f7f..8ebaa8fb53ec 100644 --- a/toolchain/check/testdata/return/fail_return_with_returned_var.carbon +++ b/toolchain/check/testdata/return/fail_return_with_returned_var.carbon @@ -53,7 +53,7 @@ fn G() -> C { // CHECK:STDOUT: %C: type = class_type @C [template] // CHECK:STDOUT: %C.elem: type = unbound_element_type %C, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %G.type: type = fn_type @G [template] // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] @@ -117,7 +117,7 @@ fn G() -> C { // CHECK:STDOUT: %.loc23_30.1: type = value_of_initializer %int.make_type_signed.loc23_30 [template = constants.%i32] // CHECK:STDOUT: %.loc23_30.2: type = converted %int.make_type_signed.loc23_30, %.loc23_30.1 [template = constants.%i32] // CHECK:STDOUT: %.loc23_28: %C.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C diff --git a/toolchain/check/testdata/return/returned_var.carbon b/toolchain/check/testdata/return/returned_var.carbon index 727ccb95b329..f59d3fe2a4ef 100644 --- a/toolchain/check/testdata/return/returned_var.carbon +++ b/toolchain/check/testdata/return/returned_var.carbon @@ -33,7 +33,7 @@ fn G() -> i32 { // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %C.elem: type = unbound_element_type %C, %i32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %struct_type.a.b.1 [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] // CHECK:STDOUT: %F: %F.type = struct_value () [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -108,7 +108,7 @@ fn G() -> i32 { // CHECK:STDOUT: %.loc13_10.1: type = value_of_initializer %int.make_type_signed.loc13 [template = constants.%i32] // CHECK:STDOUT: %.loc13_10.2: type = converted %int.make_type_signed.loc13, %.loc13_10.1 [template = constants.%i32] // CHECK:STDOUT: %.loc13_8: %C.elem = field_decl b, element1 [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type] +// CHECK:STDOUT: %complete_type: = complete_type_witness %struct_type.a.b.1 [template = constants.%complete_type.1] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C diff --git a/toolchain/check/testdata/struct/import.carbon b/toolchain/check/testdata/struct/import.carbon index ca557774bf9f..9c422c8f0f6d 100644 --- a/toolchain/check/testdata/struct/import.carbon +++ b/toolchain/check/testdata/struct/import.carbon @@ -43,10 +43,10 @@ var c_bad: C({.c = 1, .d = 2}) = F(); // --- fail_bad_value.impl.carbon impl package Implicit; -// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+6]]:1: error: cannot implicitly convert from `C()` to `C()` [ImplicitAsConversionFailure] +// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+6]]:1: error: cannot implicitly convert from `C()` to `C()` [ImplicitAsConversionFailure] // CHECK:STDERR: var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+3]]:1: note: type `C()` does not implement interface `ImplicitAs(C())` [MissingImplInMemberAccessNote] +// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+3]]:1: note: type `C()` does not implement interface `ImplicitAs(C())` [MissingImplInMemberAccessNote] // CHECK:STDERR: var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ var c_bad: C({.a = 3, .b = 4}) = F(); @@ -86,7 +86,7 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%S) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] // CHECK:STDOUT: %int_2.1: Core.IntLiteral = int_value 2 [template] // CHECK:STDOUT: %struct_type.a.b.2: type = struct_type {.a: Core.IntLiteral, .b: Core.IntLiteral} [template] @@ -196,7 +196,7 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C.1 @@ -281,7 +281,7 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] // CHECK:STDOUT: %S: %struct_type.a.b.1 = bind_symbolic_name S, 0 [symbolic] // CHECK:STDOUT: %S.patt: %struct_type.a.b.1 = symbolic_binding_pattern S, 0 [symbolic] @@ -315,8 +315,8 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.40: = import_ref Implicit//default, loc8_34, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.41 = import_ref Implicit//default, inst418 [no loc], unloaded +// CHECK:STDOUT: %import_ref.40: = import_ref Implicit//default, loc8_34, loaded [template = constants.%complete_type.1] +// CHECK:STDOUT: %import_ref.41 = import_ref Implicit//default, inst436 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -479,7 +479,7 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } // CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc8_34, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst418 [no loc], unloaded +// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst436 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -544,7 +544,7 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %struct_type.a.b.1: type = struct_type {.a: %i32, .b: %i32} [template] @@ -583,8 +583,8 @@ var c_bad: C({.a = 3, .b = 4}) = F(); // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc8_34, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst418 [no loc], unloaded +// CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc8_34, loaded [template = constants.%complete_type.1] +// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst436 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { diff --git a/toolchain/check/testdata/tuple/import.carbon b/toolchain/check/testdata/tuple/import.carbon index d9e569e9e9e0..2ea5c9c50ac3 100644 --- a/toolchain/check/testdata/tuple/import.carbon +++ b/toolchain/check/testdata/tuple/import.carbon @@ -45,10 +45,10 @@ var c_bad: C((1, 2, 3)) = F(); impl package Implicit; -// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+6]]:1: error: cannot implicitly convert from `C()` to `C()` [ImplicitAsConversionFailure] +// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+6]]:1: error: cannot implicitly convert from `C()` to `C()` [ImplicitAsConversionFailure] // CHECK:STDERR: var c_bad: C((3, 4)) = F(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ -// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+3]]:1: note: type `C()` does not implement interface `ImplicitAs(C())` [MissingImplInMemberAccessNote] +// CHECK:STDERR: fail_bad_value.impl.carbon:[[@LINE+3]]:1: note: type `C()` does not implement interface `ImplicitAs(C())` [MissingImplInMemberAccessNote] // CHECK:STDERR: var c_bad: C((3, 4)) = F(); // CHECK:STDERR: ^~~~~~~~~~~~~~~~~~~~~~~~~~~ var c_bad: C((3, 4)) = F(); @@ -102,7 +102,7 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %C.1: type = class_type @C, @C(%X) [symbolic] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.3: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %tuple.5: %tuple.type.8 = tuple_value (%int_1.2, %int_2.2) [template] // CHECK:STDOUT: %C.2: type = class_type @C, @C(%tuple.5) [template] // CHECK:STDOUT: %F.type: type = fn_type @F [template] @@ -213,7 +213,7 @@ var c_bad: C((3, 4)) = F(); // 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: = complete_type_witness %empty_struct_type [template = constants.%complete_type.3] // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .Self = constants.%C.1 @@ -313,7 +313,7 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %X: %tuple.type.7 = bind_symbolic_name X, 0 [symbolic] // CHECK:STDOUT: %X.patt: %tuple.type.7 = symbolic_binding_pattern X, 0 [symbolic] // CHECK:STDOUT: %int_1.1: Core.IntLiteral = int_value 1 [template] @@ -346,8 +346,8 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.40: = import_ref Implicit//default, loc7_26, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.41 = import_ref Implicit//default, inst455 [no loc], unloaded +// CHECK:STDOUT: %import_ref.40: = import_ref Implicit//default, loc7_26, loaded [template = constants.%complete_type.1] +// CHECK:STDOUT: %import_ref.41 = import_ref Implicit//default, inst473 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -528,7 +528,7 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } // CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc7_26, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst455 [no loc], unloaded +// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst473 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { @@ -594,7 +594,7 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: %C.type: type = generic_class_type @C [template] // CHECK:STDOUT: %C.generic: %C.type = struct_value () [template] // CHECK:STDOUT: %empty_struct_type: type = struct_type {} [template] -// CHECK:STDOUT: %complete_type: = complete_type_witness %empty_struct_type [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %empty_struct_type [template] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %i32: type = int_type signed, %int_32 [template] // CHECK:STDOUT: %tuple.type.1: type = tuple_type (%i32, %i32) [template] @@ -633,8 +633,8 @@ var c_bad: C((3, 4)) = F(); // CHECK:STDOUT: import Core//prelude // CHECK:STDOUT: import Core//prelude/... // CHECK:STDOUT: } -// CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc7_26, loaded [template = constants.%complete_type] -// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst455 [no loc], unloaded +// CHECK:STDOUT: %import_ref.39: = import_ref Implicit//default, loc7_26, loaded [template = constants.%complete_type.1] +// CHECK:STDOUT: %import_ref.40 = import_ref Implicit//default, inst473 [no loc], unloaded // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: file { diff --git a/toolchain/check/testdata/where_expr/dot_self_index.carbon b/toolchain/check/testdata/where_expr/dot_self_index.carbon index a15d8d1d5431..def337b0be96 100644 --- a/toolchain/check/testdata/where_expr/dot_self_index.carbon +++ b/toolchain/check/testdata/where_expr/dot_self_index.carbon @@ -37,6 +37,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %T.patt: type = symbolic_binding_pattern T, 0 [symbolic] // CHECK:STDOUT: %Empty.type.3: type = facet_type <@Empty, @Empty(%T)> [symbolic] // CHECK:STDOUT: %.Self.1: %Empty.type.3 = bind_symbolic_name .Self [symbolic] +// CHECK:STDOUT: %require_complete.1: = require_complete_type %Empty.type.3 [symbolic] // CHECK:STDOUT: %assoc_type.2: type = assoc_entity_type %Empty.type.3, type [symbolic] // CHECK:STDOUT: %assoc0.2: %assoc_type.2 = assoc_entity element0, @Empty.%A [symbolic] // CHECK:STDOUT: %.Self.as_wit.1: = facet_access_witness %.Self.1 [symbolic] @@ -47,6 +48,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %V.patt: type = symbolic_binding_pattern V, 1 [symbolic] // CHECK:STDOUT: %H.type: type = fn_type @H [template] // CHECK:STDOUT: %H: %H.type = struct_value () [template] +// CHECK:STDOUT: %require_complete.2: = require_complete_type %Empty_where.type.1 [symbolic] // CHECK:STDOUT: %int_32: Core.IntLiteral = int_value 32 [template] // CHECK:STDOUT: %Int.type: type = fn_type @Int [template] // CHECK:STDOUT: %Int: %Int.type = struct_value () [template] @@ -63,7 +65,9 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %G: %G.type = struct_value () [template] // CHECK:STDOUT: %Bool.type: type = fn_type @Bool [template] // CHECK:STDOUT: %Bool: %Bool.type = struct_value () [template] +// CHECK:STDOUT: %complete_type.1: = complete_type_witness %Empty.type.4 [template] // CHECK:STDOUT: %H.specific_fn: = specific_function %H, @H(%i32, bool) [template] +// CHECK:STDOUT: %complete_type.2: = complete_type_witness %Empty_where.type.2 [template] // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: imports { @@ -175,6 +179,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %T.patt.loc18_6.2: type = symbolic_binding_pattern T, 0 [symbolic = %T.patt.loc18_6.2 (constants.%T.patt)] // CHECK:STDOUT: %Empty.type.loc18_26.2: type = facet_type <@Empty, @Empty(%T.loc18_6.2)> [symbolic = %Empty.type.loc18_26.2 (constants.%Empty.type.3)] // CHECK:STDOUT: %.Self.2: @H.%Empty.type.loc18_26.2 (%Empty.type.3) = bind_symbolic_name .Self [symbolic = %.Self.2 (constants.%.Self.1)] +// CHECK:STDOUT: %require_complete.loc18_34: = require_complete_type @H.%Empty.type.loc18_26.2 (%Empty.type.3) [symbolic = %require_complete.loc18_34 (constants.%require_complete.1)] // CHECK:STDOUT: %assoc_type: type = assoc_entity_type @H.%Empty.type.loc18_26.2 (%Empty.type.3), type [symbolic = %assoc_type (constants.%assoc_type.2)] // CHECK:STDOUT: %assoc0: @H.%assoc_type (%assoc_type.2) = assoc_entity element0, @Empty.%A [symbolic = %assoc0 (constants.%assoc0.2)] // CHECK:STDOUT: %.Self.as_wit.loc18_34.2: = facet_access_witness %.Self.2 [symbolic = %.Self.as_wit.loc18_34.2 (constants.%.Self.as_wit.1)] @@ -185,6 +190,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %V.patt.loc18_43.2: type = symbolic_binding_pattern V, 1 [symbolic = %V.patt.loc18_43.2 (constants.%V.patt)] // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc18_17: = require_complete_type @H.%Empty_where.type (%Empty_where.type.1) [symbolic = %require_complete.loc18_17 (constants.%require_complete.2)] // CHECK:STDOUT: // CHECK:STDOUT: fn(%T.param_patt: type, %U.param_patt: @H.%Empty_where.type (%Empty_where.type.1), %V.param_patt: type) { // CHECK:STDOUT: !entry: @@ -239,6 +245,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %T.patt.loc18_6.2 => constants.%T // CHECK:STDOUT: %Empty.type.loc18_26.2 => constants.%Empty.type.3 // CHECK:STDOUT: %.Self.2 => constants.%.Self.1 +// CHECK:STDOUT: %require_complete.loc18_34 => constants.%require_complete.1 // CHECK:STDOUT: %assoc_type => constants.%assoc_type.2 // CHECK:STDOUT: %assoc0 => constants.%assoc0.2 // CHECK:STDOUT: %.Self.as_wit.loc18_34.2 => constants.%.Self.as_wit.1 @@ -265,6 +272,7 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %T.patt.loc18_6.2 => constants.%i32 // CHECK:STDOUT: %Empty.type.loc18_26.2 => constants.%Empty.type.4 // CHECK:STDOUT: %.Self.2 => constants.%.Self.2 +// CHECK:STDOUT: %require_complete.loc18_34 => constants.%complete_type.1 // CHECK:STDOUT: %assoc_type => constants.%assoc_type.3 // CHECK:STDOUT: %assoc0 => constants.%assoc0.3 // CHECK:STDOUT: %.Self.as_wit.loc18_34.2 => constants.%.Self.as_wit.2 @@ -275,5 +283,6 @@ fn G(U: Empty(i32) where .A = i32*) { // CHECK:STDOUT: %V.patt.loc18_43.2 => bool // CHECK:STDOUT: // CHECK:STDOUT: !definition: +// CHECK:STDOUT: %require_complete.loc18_17 => constants.%complete_type.2 // CHECK:STDOUT: } // CHECK:STDOUT: diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def index d9f0bb0cb030..738d43113d83 100644 --- a/toolchain/diagnostics/diagnostic_kind.def +++ b/toolchain/diagnostics/diagnostic_kind.def @@ -323,6 +323,7 @@ CARBON_DIAGNOSTIC_KIND(IncompleteTypeInBaseDecl) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInConversion) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInFunctionParam) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInFunctionReturnType) +CARBON_DIAGNOSTIC_KIND(IncompleteTypeInMonomorphization) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInLetDecl) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInMemberAccess) CARBON_DIAGNOSTIC_KIND(IncompleteTypeInValueConversion) diff --git a/toolchain/sem_ir/file.cpp b/toolchain/sem_ir/file.cpp index fc3683225067..336938417e82 100644 --- a/toolchain/sem_ir/file.cpp +++ b/toolchain/sem_ir/file.cpp @@ -273,6 +273,7 @@ auto GetExprCategory(const File& file, InstId inst_id) -> ExprCategory { case LegacyFloatType::Kind: case NamespaceType::Kind: case PointerType::Kind: + case RequireCompleteType::Kind: case SpecificFunction::Kind: case SpecificFunctionType::Kind: case StringLiteral::Kind: diff --git a/toolchain/sem_ir/formatter.cpp b/toolchain/sem_ir/formatter.cpp index ff70a25b3e9d..79cd833ea318 100644 --- a/toolchain/sem_ir/formatter.cpp +++ b/toolchain/sem_ir/formatter.cpp @@ -902,6 +902,10 @@ class FormatterImpl { llvm::ArrayRef args = sem_ir_->inst_blocks().Get(inst.args_id); auto return_info = ReturnTypeInfo::ForType(*sem_ir_, inst.type_id); + if (!return_info.is_valid()) { + out_ << "()"; + return; + } bool has_return_slot = return_info.has_return_slot(); InstId return_slot_arg_id = InstId::Invalid; if (has_return_slot) { diff --git a/toolchain/sem_ir/inst_kind.def b/toolchain/sem_ir/inst_kind.def index 4e5603a20aa0..49d75d91916b 100644 --- a/toolchain/sem_ir/inst_kind.def +++ b/toolchain/sem_ir/inst_kind.def @@ -83,6 +83,7 @@ CARBON_SEM_IR_INST_KIND(NamespaceType) CARBON_SEM_IR_INST_KIND(OutParam) CARBON_SEM_IR_INST_KIND(OutParamPattern) CARBON_SEM_IR_INST_KIND(PointerType) +CARBON_SEM_IR_INST_KIND(RequireCompleteType) CARBON_SEM_IR_INST_KIND(RequirementEquivalent) CARBON_SEM_IR_INST_KIND(RequirementImpls) CARBON_SEM_IR_INST_KIND(RequirementRewrite) diff --git a/toolchain/sem_ir/inst_namer.cpp b/toolchain/sem_ir/inst_namer.cpp index c2c1fdcb23af..454da12adfb9 100644 --- a/toolchain/sem_ir/inst_namer.cpp +++ b/toolchain/sem_ir/inst_namer.cpp @@ -694,7 +694,11 @@ auto InstNamer::CollectNamesInBlock(ScopeId scope_id, add_inst_name("ptr"); continue; } - case InstKind::ReturnSlotPattern: { + case RequireCompleteType::Kind: { + add_inst_name("require_complete"); + continue; + } + case ReturnSlotPattern::Kind: { add_inst_name_id(NameId::ReturnSlot, ".patt"); continue; } @@ -712,7 +716,7 @@ auto InstNamer::CollectNamesInBlock(ScopeId scope_id, } continue; } - case InstKind::ReturnSlot: { + case ReturnSlot::Kind: { add_inst_name_id(NameId::ReturnSlot); break; } diff --git a/toolchain/sem_ir/stringify_type.cpp b/toolchain/sem_ir/stringify_type.cpp index 3f74c1971dcc..9429bc376765 100644 --- a/toolchain/sem_ir/stringify_type.cpp +++ b/toolchain/sem_ir/stringify_type.cpp @@ -470,6 +470,7 @@ auto StringifyTypeExpr(const SemIR::File& sem_ir, InstId outer_inst_id) case InterfaceWitness::Kind: case OutParam::Kind: case OutParamPattern::Kind: + case RequireCompleteType::Kind: case RequirementEquivalent::Kind: case RequirementImpls::Kind: case RequirementRewrite::Kind: diff --git a/toolchain/sem_ir/typed_insts.h b/toolchain/sem_ir/typed_insts.h index 50a83b2d5a51..b2cdaca8f21a 100644 --- a/toolchain/sem_ir/typed_insts.h +++ b/toolchain/sem_ir/typed_insts.h @@ -1059,6 +1059,25 @@ struct PointerType { TypeId pointee_id; }; +// Requires a type to be complete. This is only created for generic types and +// produces a witness that the type is complete. +// +// TODO: Eventually this should be replaced by a witness for an interface that +// models type completeness, and should track other information such as the +// value representation. +struct RequireCompleteType { + static constexpr auto Kind = + InstKind::RequireCompleteType.Define( + {.ir_name = "require_complete_type", + .is_type = InstIsType::Never, + .constant_kind = InstConstantKind::SymbolicOnly, + .is_lowered = false}); + // Always the builtin witness type. + TypeId type_id; + // The type that is required to be complete. + TypeId complete_type_id; +}; + struct Return { static constexpr auto Kind = InstKind::Return.Define