Replace GetTypeInSpecific with GetTypeOfInstInSpecific. (carbon-language#5232)

Reduce usage of `GetConstantInSpecific` to a single caller in constant
evaluation, with a TODO to remove that.

This gets us closer to being able to fully perform type-checking against
abstract types instead of types anchored within a particular generic.

Author: zygoloid

toolchain/check/eval.cpp

@@ -96,26 +96,36 @@ class EvalContext {
 
     // While resolving a specific, map from previous instructions in the eval
     // block into their evaluated values. These values won't be present on the
-    // specific itself yet, so `GetConstantInSpecific` won't be able to find
-    // them.
-    if (specific_eval_info_) {
-      const auto& symbolic_info =
-          constant_values().GetSymbolicConstant(const_id);
-      if (symbolic_info.index.has_value() &&
-          symbolic_info.generic_id ==
-              specifics().Get(specific_id_).generic_id &&
-          symbolic_info.index.region() == specific_eval_info_->region) {
+    // specific itself yet, so `GetConstantValueInSpecific` won't be able to
+    // find them.
+    const auto& symbolic_info = constant_values().GetSymbolicConstant(const_id);
+    if (specific_eval_info_ && symbolic_info.index.has_value()) {
+      CARBON_CHECK(
+          symbolic_info.generic_id == specifics().Get(specific_id_).generic_id,
+          "Instruction has constant operand in wrong generic");
+      if (symbolic_info.index.region() == specific_eval_info_->region) {
         auto inst_id = specific_eval_info_->values[symbolic_info.index.index()];
         CARBON_CHECK(inst_id.has_value(),
                      "Forward reference in eval block: index {0} referenced "
                      "before evaluation",
                      symbolic_info.index.index());
         return constant_values().Get(inst_id);
+      } else {
+        // TODO: Eliminate this call. This is the only place where we get a
+        // value from a specific without using an InstId. There are three ways
+        // we can get here:
+        // 1) From GetConstantValue(InstId): these can use
+        //    GetConstantValueInSpecific.
+        // 2) From GetConstantValue(TypeId): for these, we could change
+        //    instructions so they store InstIds instead of TypeIds.
+        // 3) From GetConstantFacetTypeInfo: for these, we could store an
+        //    InstId instead of a ConstantId in rewrite_constraints.
+        return GetConstantInSpecific(sem_ir(), specific_id_, const_id);
       }
     }
 
     // Map from a specific constant value to the canonical value.
-    return GetConstantInSpecific(sem_ir(), specific_id_, const_id);
+    return constant_values().Get(symbolic_info.inst_id);
   }
 
   // Gets the constant value of the specified instruction in this context.

toolchain/check/eval_inst.cpp

@@ -243,7 +243,7 @@ auto EvalConstantInst(Context& context, SemIRLoc loc,
 
 auto EvalConstantInst(Context& context, SemIRLoc loc,
                       SemIR::ImplWitnessAccess inst) -> ConstantEvalResult {
-  // This is PerformAggregateAccess followed by GetConstantInSpecific.
+  // This is PerformAggregateAccess followed by GetConstantValueInSpecific.
   if (auto witness =
           context.insts().TryGetAs<SemIR::ImplWitness>(inst.witness_id)) {
     auto elements = context.inst_blocks().Get(witness->elements_id);

toolchain/check/handle_name.cpp

@@ -109,10 +109,10 @@ static auto HandleNameAsExpr(Context& context, Parse::NodeId node_id,
                              SemIR::NameId name_id) -> SemIR::InstId {
   auto result = LookupUnqualifiedName(context, node_id, name_id);
   SemIR::InstId inst_id = result.scope_result.target_inst_id();
-  auto value = context.insts().Get(inst_id);
-  auto type_id = SemIR::GetTypeInSpecific(context.sem_ir(), result.specific_id,
-                                          value.type_id());
-  CARBON_CHECK(type_id.has_value(), "Missing type for {0}", value);
+  auto type_id = SemIR::GetTypeOfInstInSpecific(context.sem_ir(),
+                                                result.specific_id, inst_id);
+  CARBON_CHECK(type_id.has_value(), "Missing type for {0}",
+               context.insts().Get(inst_id));
 
   // If the named entity has a constant value that depends on its specific,
   // store the specific too.

toolchain/check/interface.cpp

@@ -81,9 +81,8 @@ static auto GetSelfFacet(Context& context,
                          SemIR::InstId self_witness_id) -> SemIR::InstId {
   auto self_binding_id =
       GetSelfBinding(context, interface_specific_id, generic_id);
-  auto self_binding = context.insts().Get(self_binding_id);
-  auto self_facet_type_id = SemIR::GetTypeInSpecific(
-      context.sem_ir(), interface_specific_id, self_binding.type_id());
+  auto self_facet_type_id = SemIR::GetTypeOfInstInSpecific(
+      context.sem_ir(), interface_specific_id, self_binding_id);
   // Create a facet value to be the value of `Self` in the interface.
   // TODO: Pass this in instead of creating it here. The caller sometimes
   // already has a facet value.
@@ -190,15 +189,14 @@ auto GetTypeForSpecificAssociatedEntity(Context& context, SemIRLoc loc,
         GetGenericArgsWithSelfType(context, interface_specific_id, generic_id,
                                    self_type_id, self_witness_id);
     auto const_specific_id = MakeSpecific(context, loc, generic_id, arg_ids);
-    return SemIR::GetTypeInSpecific(context.sem_ir(), const_specific_id,
-                                    context.insts().Get(decl_id).type_id());
+    return SemIR::GetTypeOfInstInSpecific(context.sem_ir(), const_specific_id,
+                                          decl_id);
   } else if (auto fn = context.types().TryGetAs<SemIR::FunctionType>(
                  decl.type_id())) {
     // Form the type of the function within the interface, and attach the `Self`
     // type.
-    auto interface_fn_type_id =
-        SemIR::GetTypeInSpecific(context.sem_ir(), interface_specific_id,
-                                 context.insts().Get(decl_id).type_id());
+    auto interface_fn_type_id = SemIR::GetTypeOfInstInSpecific(
+        context.sem_ir(), interface_specific_id, decl_id);
     auto self_facet_id =
         GetSelfFacet(context, interface_specific_id,
                      context.functions().Get(fn->function_id).generic_id,

toolchain/check/member_access.cpp

@@ -261,10 +261,11 @@ static auto LookupMemberNameInScope(Context& context, SemIR::LocId loc_id,
   }
 
   // TODO: This duplicates the work that HandleNameAsExpr does. Factor this out.
-  auto inst = context.insts().Get(result.scope_result.target_inst_id());
-  auto type_id = SemIR::GetTypeInSpecific(context.sem_ir(), result.specific_id,
-                                          inst.type_id());
-  CARBON_CHECK(type_id.has_value(), "Missing type for member {0}", inst);
+  auto type_id =
+      SemIR::GetTypeOfInstInSpecific(context.sem_ir(), result.specific_id,
+                                     result.scope_result.target_inst_id());
+  CARBON_CHECK(type_id.has_value(), "Missing type for member {0}",
+               context.insts().Get(result.scope_result.target_inst_id()));
 
   // If the named entity has a constant value that depends on its specific,
   // store the specific too.

toolchain/check/merge.cpp

@@ -203,6 +203,9 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
                              SemIR::InstId prev_param_pattern_id,
                              SemIR::SpecificId prev_specific_id, bool diagnose,
                              bool check_self) -> bool {
+  auto orig_new_param_pattern_id = new_param_pattern_id;
+  auto orig_prev_param_pattern_id = prev_param_pattern_id;
+
   // TODO: Consider differentiating between type and name mistakes. For now,
   // taking the simpler approach because I also think we may want to refactor
   // params.
@@ -218,9 +221,10 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
                       "redeclaration differs at {0:implicit |}parameter {1}",
                       Diagnostics::BoolAsSelect, int32_t);
     context.emitter()
-        .Build(new_param_pattern_id, RedeclParamDiffers, is_implicit_param,
+        .Build(orig_new_param_pattern_id, RedeclParamDiffers, is_implicit_param,
                param_index + 1)
-        .Note(prev_param_pattern_id, RedeclParamPrevious, is_implicit_param)
+        .Note(orig_prev_param_pattern_id, RedeclParamPrevious,
+              is_implicit_param)
         .Emit();
   };
 
@@ -232,21 +236,24 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
   }
 
   if (new_param_pattern.Is<SemIR::AddrPattern>()) {
-    new_param_pattern = context.insts().Get(
-        new_param_pattern.As<SemIR::AddrPattern>().inner_id);
-    prev_param_pattern = context.insts().Get(
-        prev_param_pattern.As<SemIR::AddrPattern>().inner_id);
+    new_param_pattern_id = new_param_pattern.As<SemIR::AddrPattern>().inner_id;
+    new_param_pattern = context.insts().Get(new_param_pattern_id);
+    prev_param_pattern_id =
+        prev_param_pattern.As<SemIR::AddrPattern>().inner_id;
+    prev_param_pattern = context.insts().Get(prev_param_pattern_id);
     if (new_param_pattern.kind() != prev_param_pattern.kind()) {
       emit_diagnostic();
       return false;
     }
   }
 
   if (new_param_pattern.Is<SemIR::AnyParamPattern>()) {
-    new_param_pattern = context.insts().Get(
-        new_param_pattern.As<SemIR::ValueParamPattern>().subpattern_id);
-    prev_param_pattern = context.insts().Get(
-        prev_param_pattern.As<SemIR::ValueParamPattern>().subpattern_id);
+    new_param_pattern_id =
+        new_param_pattern.As<SemIR::ValueParamPattern>().subpattern_id;
+    new_param_pattern = context.insts().Get(new_param_pattern_id);
+    prev_param_pattern_id =
+        prev_param_pattern.As<SemIR::ValueParamPattern>().subpattern_id;
+    prev_param_pattern = context.insts().Get(prev_param_pattern_id);
     if (new_param_pattern.kind() != prev_param_pattern.kind()) {
       emit_diagnostic();
       return false;
@@ -267,8 +274,8 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
     return true;
   }
 
-  auto prev_param_type_id = SemIR::GetTypeInSpecific(
-      context.sem_ir(), prev_specific_id, prev_param_pattern.type_id());
+  auto prev_param_type_id = SemIR::GetTypeOfInstInSpecific(
+      context.sem_ir(), prev_specific_id, prev_param_pattern_id);
   if (!context.types().AreEqualAcrossDeclarations(new_param_pattern.type_id(),
                                                   prev_param_type_id)) {
     if (!diagnose) {
@@ -280,9 +287,11 @@ static auto CheckRedeclParam(Context& context, bool is_implicit_param,
                       Diagnostics::BoolAsSelect, int32_t, SemIR::TypeId,
                       SemIR::TypeId);
     context.emitter()
-        .Build(new_param_pattern_id, RedeclParamDiffersType, is_implicit_param,
-               param_index + 1, prev_param_type_id, new_param_pattern.type_id())
-        .Note(prev_param_pattern_id, RedeclParamPrevious, is_implicit_param)
+        .Build(orig_new_param_pattern_id, RedeclParamDiffersType,
+               is_implicit_param, param_index + 1, prev_param_type_id,
+               new_param_pattern.type_id())
+        .Note(orig_prev_param_pattern_id, RedeclParamPrevious,
+              is_implicit_param)
         .Emit();
     return false;
   }