Emit function definitions in check, for all specifics seen. (carbon-language#5090)

Emitting definitions in check. This resolves the crash in lowering which
necessitated definitions be emitted.
Some of the test changes need further review.

Author: alinas

toolchain/check/call.cpp

@@ -189,8 +189,6 @@ auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,
                   context, SemIR::SpecificFunctionType::SingletonInstId),
               .callee_id = generic_callee_id,
               .specific_id = *callee_specific_id});
-      // TODO: Add to `definitions_required` when evaluating the
-      // `SpecificImplFunction`.
     } else {
       // This is a regular generic function. The callee is the specific function
       // we deduced.
@@ -201,9 +199,6 @@ auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,
                   context, SemIR::SpecificFunctionType::SingletonInstId),
               .callee_id = generic_callee_id,
               .specific_id = *callee_specific_id});
-      // TODO: The specific function could be a symbolic constant. Delay doing
-      // this until we form a concrete `SpecificFunction` constant.
-      context.definitions_required().push_back(callee_id);
     }
 
     // Add the `self` argument back if there was one.

toolchain/check/check_unit.cpp

@@ -20,6 +20,8 @@
 #include "toolchain/check/inst.h"
 #include "toolchain/check/node_id_traversal.h"
 #include "toolchain/check/type.h"
+#include "toolchain/sem_ir/function.h"
+#include "toolchain/sem_ir/ids.h"
 #include "toolchain/sem_ir/import_ir.h"
 
 namespace Carbon::Check {
@@ -440,9 +442,11 @@ auto CheckUnit::CheckRequiredDeclarations() -> void {
 auto CheckUnit::CheckRequiredDefinitions() -> void {
   CARBON_DIAGNOSTIC(MissingDefinitionInImpl, Error,
                     "no definition found for declaration in impl file");
+
   // Note that more required definitions can be added during this loop.
-  for (size_t i = 0; i != context_.definitions_required().size(); ++i) {
-    SemIR::InstId decl_inst_id = context_.definitions_required()[i];
+  // NOLINTNEXTLINE(modernize-loop-convert)
+  for (size_t i = 0; i != context_.definitions_required_by_decl().size(); ++i) {
+    SemIR::InstId decl_inst_id = context_.definitions_required_by_decl()[i];
     SemIR::Inst decl_inst = context_.insts().Get(decl_inst_id);
     CARBON_KIND_SWITCH(context_.insts().Get(decl_inst_id)) {
       case CARBON_KIND(SemIR::ClassDecl class_decl): {
@@ -474,33 +478,32 @@ auto CheckUnit::CheckRequiredDefinitions() -> void {
         // https://github.com/carbon-language/carbon-lang/issues/4071.
         CARBON_FATAL("TODO: Support interfaces in DiagnoseMissingDefinitions");
       }
-      case CARBON_KIND(SemIR::SpecificFunction specific_function): {
-        // TODO: Track a location for the use. In general we may want to track a
-        // list of enclosing locations if this was used from a generic.
-        SemIRLoc use_loc = decl_inst_id;
-        if (!ResolveSpecificDefinition(context_, use_loc,
-                                       specific_function.specific_id)) {
-          CARBON_DIAGNOSTIC(MissingGenericFunctionDefinition, Error,
-                            "use of undefined generic function");
-          CARBON_DIAGNOSTIC(MissingGenericFunctionDefinitionHere, Note,
-                            "generic function declared here");
-          auto generic_decl_id =
-              context_.generics()
-                  .Get(context_.specifics()
-                           .Get(specific_function.specific_id)
-                           .generic_id)
-                  .decl_id;
-          emitter_.Build(decl_inst_id, MissingGenericFunctionDefinition)
-              .Note(generic_decl_id, MissingGenericFunctionDefinitionHere)
-              .Emit();
-        }
-        break;
-      }
       default: {
         CARBON_FATAL("Unexpected inst in definitions_required: {0}", decl_inst);
       }
     }
   }
+
+  // Note that more required definitions can be added during this loop.
+  // NOLINTNEXTLINE(modernize-loop-convert)
+  for (size_t i = 0; i != context_.definitions_required_by_use().size(); ++i) {
+    // This is using the location for the use. We could track the
+    // list of enclosing locations if this was used from a generic.
+    auto [loc, specific_id] = context_.definitions_required_by_use()[i];
+    if (!ResolveSpecificDefinition(context_, loc, specific_id)) {
+      CARBON_DIAGNOSTIC(MissingGenericFunctionDefinition, Error,
+                        "use of undefined generic function");
+      CARBON_DIAGNOSTIC(MissingGenericFunctionDefinitionHere, Note,
+                        "generic function declared here");
+      auto generic_decl_id =
+          context_.generics()
+              .Get(context_.specifics().Get(specific_id).generic_id)
+              .decl_id;
+      emitter_.Build(loc, MissingGenericFunctionDefinition)
+          .Note(generic_decl_id, MissingGenericFunctionDefinitionHere)
+          .Emit();
+    }
+  }
 }
 
 auto CheckUnit::FinishRun() -> void {

toolchain/check/check_unit.h

@@ -162,8 +162,8 @@ class CheckUnit {
 
   // Checks that each required definition is available. If the definition can be
   // generated by resolving a specific, does so, otherwise emits a diagnostic
-  // for each declaration in context.definitions_required() that doesn't have a
-  // definition.
+  // for each declaration in context.definitions_required_by_decl() and
+  // context.definitions_required_by_use that doesn't have a definition.
   auto CheckRequiredDefinitions() -> void;
 
   // Does work after processing the parse tree, such as finishing the IR and

toolchain/check/context.h

@@ -147,8 +147,13 @@ class Context {
     return import_ir_constant_values_;
   }
 
-  auto definitions_required() -> llvm::SmallVector<SemIR::InstId>& {
-    return definitions_required_;
+  auto definitions_required_by_decl() -> llvm::SmallVector<SemIR::InstId>& {
+    return definitions_required_by_decl_;
+  }
+
+  auto definitions_required_by_use()
+      -> llvm::SmallVector<std::pair<SemIRLoc, SemIR::SpecificId>>& {
+    return definitions_required_by_use_;
   }
 
   auto global_init() -> GlobalInit& { return global_init_; }
@@ -343,7 +348,13 @@ class Context {
 
   // Declaration instructions of entities that should have definitions by the
   // end of the current source file.
-  llvm::SmallVector<SemIR::InstId> definitions_required_;
+  llvm::SmallVector<SemIR::InstId> definitions_required_by_decl_;
+
+  // Entities that should have definitions by the end of the current source
+  // file, because of a generic was used a concrete specific. This is currently
+  // only tracking specific functions that should have a definition emitted.
+  llvm::SmallVector<std::pair<SemIRLoc, SemIR::SpecificId>>
+      definitions_required_by_use_;
 
   // State for global initialization.
   GlobalInit global_init_;

toolchain/check/eval_inst.cpp

@@ -11,6 +11,7 @@
 #include "toolchain/check/generic.h"
 #include "toolchain/check/impl_lookup.h"
 #include "toolchain/check/import_ref.h"
+#include "toolchain/check/inst.h"
 #include "toolchain/check/type.h"
 #include "toolchain/check/type_completion.h"
 #include "toolchain/sem_ir/ids.h"
@@ -393,14 +394,26 @@ auto EvalConstantInst(Context& context, SemIRLoc loc,
   args.append(interface_fn_args.end() - remaining_params,
               interface_fn_args.end());
   auto specific_id = MakeSpecific(context, loc, generic_id, args);
+  context.definitions_required_by_use().push_back({loc, specific_id});
 
-  // TODO: Add the new `SpecificFunction` to definitions_required.
   return ConstantEvalResult::NewSamePhase(
       SemIR::SpecificFunction{.type_id = inst.type_id,
                               .callee_id = inst.callee_id,
                               .specific_id = specific_id});
 }
 
+auto EvalConstantInst(Context& context, SemIRLoc loc,
+                      SemIR::SpecificFunction inst) -> ConstantEvalResult {
+  if (!SemIR::GetCalleeFunction(context.sem_ir(), inst.callee_id)
+           .self_type_id.has_value()) {
+    // This is not an associated function. Those will be required to be defined
+    // as part of checking that the impl is complete.
+    context.definitions_required_by_use().push_back({loc, inst.specific_id});
+  }
+  // Create new constant for a specific function.
+  return ConstantEvalResult::NewSamePhase(inst);
+}
+
 auto EvalConstantInst(Context& context, SemIRLoc /*loc*/,
                       SemIR::SpliceBlock inst) -> ConstantEvalResult {
   // SpliceBlock evaluates to the result value that is (typically) within the

toolchain/check/handle_class.cpp

@@ -275,7 +275,7 @@ static auto BuildClassDecl(Context& context, Parse::AnyClassDeclId node_id,
   }
 
   if (!is_definition && context.sem_ir().is_impl() && !is_extern) {
-    context.definitions_required().push_back(class_decl_id);
+    context.definitions_required_by_decl().push_back(class_decl_id);
   }
 
   return {class_decl.class_id, class_decl_id};

toolchain/check/handle_function.cpp

@@ -531,7 +531,7 @@ static auto BuildFunctionDecl(Context& context,
                         function_info);
 
   if (!is_definition && context.sem_ir().is_impl() && !is_extern) {
-    context.definitions_required().push_back(decl_id);
+    context.definitions_required_by_decl().push_back(decl_id);
   }
 
   return {function_decl.function_id, decl_id};

toolchain/check/handle_impl.cpp

@@ -506,7 +506,7 @@ static auto BuildImplDecl(Context& context, Parse::AnyImplDeclId node_id,
   if (!is_definition && !invalid_redeclaration &&
       context.impls().Get(impl_decl.impl_id).witness_id !=
           SemIR::ErrorInst::SingletonInstId) {
-    context.definitions_required().push_back(impl_decl_id);
+    context.definitions_required_by_decl().push_back(impl_decl_id);
   }
 
   return {impl_decl.impl_id, impl_decl_id};

toolchain/check/testdata/facet/min_prelude/convert_facet_value_to_itself.carbon

@@ -172,6 +172,8 @@ fn F() {
 // CHECK:STDOUT: specific @FeedAnimal(constants.%Animal.facet) {
 // CHECK:STDOUT:   %T.loc16_15.2 => constants.%Animal.facet
 // CHECK:STDOUT:   %T.patt.loc16_15.2 => constants.%T.patt
+// CHECK:STDOUT:
+// CHECK:STDOUT: !definition:
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- include_files/convert.carbon

toolchain/check/testdata/facet/min_prelude/convert_facet_value_value_to_generic_facet_value_value.carbon

@@ -532,6 +532,10 @@ fn F() {
 // CHECK:STDOUT:   %T.loc30_24.2 => constants.%Eats.facet.fa6
 // CHECK:STDOUT:   %T.patt.loc30_24.2 => constants.%T.patt.1ac
 // CHECK:STDOUT:   %T.as_type.loc30_43.2 => constants.%Goat
+// CHECK:STDOUT:
+// CHECK:STDOUT: !definition:
+// CHECK:STDOUT:   %require_complete.loc30_41 => constants.%complete_type.357
+// CHECK:STDOUT:   %require_complete.loc30_50 => constants.%complete_type.357
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: --- include_files/convert.carbon