test

Author: jonmeow

toolchain/check/check_unit.cpp

@@ -499,6 +499,8 @@ auto CheckUnit::CheckRequiredDefinitions() -> void {
 
   for (auto [loc, specific_id] :
        GrowingRange(context_.definitions_required_by_use())) {
+    // FIXME
+    continue;
     // This is using the location for the use. We could track the
     // list of enclosing locations if this was used from a generic.
     if (!ResolveSpecificDefinition(context_, loc, specific_id)) {

toolchain/check/eval_inst.cpp

@@ -492,6 +492,11 @@ auto EvalConstantInst(Context& context, SemIR::InstId inst_id,
   return ConstantEvalResult::NewSamePhase(inst);
 }
 
+auto EvalConstantInst(Context& /*context*/, SemIR::RequireImplDefinition inst)
+    -> ConstantEvalResult {
+  return ConstantEvalResult::NewSamePhase(inst);
+}
+
 auto EvalConstantInst(Context& context, SemIR::SpecificConstant inst)
     -> ConstantEvalResult {
   // Pull the constant value out of the specific.

toolchain/check/generic.cpp

@@ -709,6 +709,7 @@ auto MakeSelfSpecific(Context& context, SemIR::LocId loc_id,
   return specific_id;
 }
 
+// NOLINT(misc-no-recursion): FIXME
 auto ResolveSpecificDefinition(Context& context, SemIR::LocId loc_id,
                                SemIR::SpecificId specific_id) -> bool {
   // TODO: Handle recursive resolution of the same generic definition.
@@ -723,6 +724,22 @@ auto ResolveSpecificDefinition(Context& context, SemIR::LocId loc_id,
       // The generic is not defined yet.
       return false;
     }
+    for (auto inst_id :
+         context.inst_blocks().Get(generic.definition_block_id)) {
+      auto req_impl =
+          context.insts().TryGetAs<SemIR::RequireImplDefinition>(inst_id);
+      if (!req_impl) {
+        continue;
+      }
+      auto def_id = req_impl->specific_id;
+      const auto& def_specific = context.specifics().Get(def_id);
+      if (const auto& def_generic =
+              context.generics().Get(def_specific.generic_id);
+          def_generic.self_specific_id.has_value()) {
+        def_id = def_generic.self_specific_id;
+      }
+      ResolveSpecificDefinition(context, loc_id, def_id);
+    }
     specific.definition_block_id = TryEvalBlockForSpecific(
         context, loc_id, specific_id, SemIR::GenericInstIndex::Definition);
   }

toolchain/check/impl_lookup.cpp

@@ -232,18 +232,30 @@ static auto GetWitnessIdForImpl(Context& context, SemIR::LocId loc_id,
 
   // The self type of the impl must match the type in the query, or this is an
   // `impl T as ...` for some other type `T` and should not be considered.
-  auto deduced_self_const_id = SemIR::GetConstantValueInSpecific(
+  auto noncanonical_deduced_self_const_id = SemIR::GetConstantValueInSpecific(
       context.sem_ir(), specific_id, impl.self_id);
+
   // In a generic `impl forall` the self type can be a FacetAccessType, which
   // will not be the same constant value as a query facet value. We move through
   // to the facet value here, and if the query was a FacetAccessType we did the
   // same there so they still match.
-  deduced_self_const_id =
-      GetCanonicalFacetOrTypeValue(context, deduced_self_const_id);
+  auto deduced_self_const_id =
+      GetCanonicalFacetOrTypeValue(context, noncanonical_deduced_self_const_id);
   if (query_self_const_id != deduced_self_const_id) {
     return EvalImplLookupResult::MakeNone();
   }
 
+  // When working with a symbolic constant and a `final` impl, add an
+  // instruction to support requiring an impl definition which may not
+  // otherwise be generated.
+  if (impl.is_final && deduced_self_const_id.is_symbolic()) {
+    AddInstInNoBlock(context, loc_id,
+                     SemIR::RequireImplDefinition{
+                         .type_id = GetSingletonType(
+                             context, SemIR::WitnessType::TypeInstId),
+                         .specific_id = specific_id});
+  }
+
   // The impl's constraint is a facet type which it is implementing for the self
   // type: the `I` in `impl ... as I`. The deduction step may be unable to be
   // fully applied to the types in the constraint and result in an error here,

toolchain/check/import_ref.cpp

@@ -2884,6 +2884,27 @@ static auto TryResolveTypedInst(ImportRefResolver& resolver,
                  .complete_type_inst_id = complete_type_inst_id});
 }
 
+static auto TryResolveTypedInst(ImportRefResolver& resolver,
+                                SemIR::RequireImplDefinition inst)
+    -> ResolveResult {
+  CARBON_CHECK(resolver.import_types().GetInstId(inst.type_id) ==
+               SemIR::WitnessType::TypeInstId);
+
+  auto specific_data = GetLocalSpecificData(resolver, inst.specific_id);
+
+  if (resolver.HasNewWork()) {
+    return ResolveResult::Retry();
+  }
+
+  auto specific_id =
+      GetOrAddLocalSpecific(resolver, inst.specific_id, specific_data);
+
+  return ResolveAsDeduplicated<SemIR::RequireImplDefinition>(
+      resolver, {.type_id = GetSingletonType(resolver.local_context(),
+                                             SemIR::WitnessType::TypeInstId),
+                 .specific_id = specific_id});
+}
+
 static auto TryResolveTypedInst(ImportRefResolver& resolver,
                                 SemIR::ReturnSlotPattern inst,
                                 SemIR::InstId import_inst_id) -> ResolveResult {
@@ -3349,6 +3370,9 @@ static auto TryResolveInstCanonical(ImportRefResolver& resolver,
     case CARBON_KIND(SemIR::RequireCompleteType inst): {
       return TryResolveTypedInst(resolver, inst);
     }
+    case CARBON_KIND(SemIR::RequireImplDefinition inst): {
+      return TryResolveTypedInst(resolver, inst);
+    }
     case CARBON_KIND(SemIR::ReturnSlotPattern inst): {
       return TryResolveTypedInst(resolver, inst, constant_inst_id);
     }