symbolic-binding-type

Author: danakj

toolchain/check/convert.cpp

@@ -828,29 +828,20 @@ static auto CanRemoveQualifiers(SemIR::TypeQualifiers quals,
 static auto DiagnoseConversionFailureToConstraintValue(
     Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
     SemIR::TypeId target_type_id) -> void {
-  CARBON_DCHECK(target_type_id == SemIR::TypeType::TypeId ||
-                context.types().Is<SemIR::FacetType>(target_type_id));
+  CARBON_CHECK(context.types().IsFacetType(target_type_id));
 
-  auto type_of_expr_id = context.insts().Get(expr_id).type_id();
-  CARBON_CHECK(context.types().IsFacetType(type_of_expr_id));
   // If the source type is/has a facet value, then we can include its
   // FacetType in the diagnostic to help explain what interfaces the
   // source type implements.
-  auto facet_value_inst_id = SemIR::InstId::None;
-  if (auto facet_access_type =
-          context.insts().TryGetAs<SemIR::FacetAccessType>(expr_id)) {
-    facet_value_inst_id = facet_access_type->facet_value_inst_id;
-  } else if (context.types().Is<SemIR::FacetType>(type_of_expr_id)) {
-    facet_value_inst_id = expr_id;
-  }
+  auto facet_type_inst_id = GetCanonicalizedFacetTypeOrType(context, expr_id);
 
-  if (facet_value_inst_id.has_value()) {
+  if (context.insts().Is<SemIR::FacetType>(facet_type_inst_id)) {
     CARBON_DIAGNOSTIC(ConversionFailureFacetToFacet, Error,
                       "cannot convert type {0} that implements {1} into type "
                       "implementing {2}",
-                      InstIdAsType, TypeOfInstId, SemIR::TypeId);
+                      InstIdAsType, InstIdAsType, SemIR::TypeId);
     context.emitter().Emit(loc_id, ConversionFailureFacetToFacet, expr_id,
-                           facet_value_inst_id, target_type_id);
+                           facet_type_inst_id, target_type_id);
   } else {
     CARBON_DIAGNOSTIC(ConversionFailureTypeToFacet, Error,
                       "cannot convert type {0} into type implementing {1}",
@@ -1219,8 +1210,9 @@ static auto PerformBuiltinConversion(
       const_type_inst_id = sem_ir.constant_values().GetConstantTypeInstId(
           context.types().GetAsTypeInstId(value_id));
 
-      // Lossless round trips through a FacetAccessType when converting back to
-      // the type of its original facet value.
+      // Lossless round trips through a FacetAccessType (which evaluates to
+      // SymbolicBindingType) when converting back to the type of its original
+      // facet value.
       //
       // Given a symbolic facet value X, if a FacetAccessType(X) is converted to
       // the type of X, we make the past introduction of the FacetAccessType
@@ -1239,12 +1231,11 @@ static auto PerformBuiltinConversion(
       //
       // See also test:
       // facet_access_type_converts_back_to_original_facet_value.carbon
-      //
-      // TODO: This instruction is going to become a `SymbolicBindingType`, so
-      // we'll need to handle that instead.
       if (auto facet_access_type_inst =
-              sem_ir.insts().TryGetAs<SemIR::FacetAccessType>(
+              sem_ir.insts().TryGetAs<SemIR::SymbolicBindingType>(
                   const_type_inst_id)) {
+        // TODO: Look in ScopeStack with the the entity_name_id to find the
+        // facet value.
         auto facet_value_inst_id = facet_access_type_inst->facet_value_inst_id;
         if (sem_ir.insts().Get(facet_value_inst_id).type_id() ==
             target.type_id) {

toolchain/check/deduce.cpp

@@ -411,7 +411,7 @@ auto DeductionContext::Deduce() -> bool {
         // TODO: Match field name order between param and arg.
         break;
 
-      case CARBON_KIND(SemIR::FacetAccessType access): {
+      case CARBON_KIND(SemIR::SymbolicBindingType binding): {
         // Given `fn F[G:! Interface](g: G)`, the type of `g` is `G as type`.
         // `G` is a symbolic binding, whose type is a facet type, but `G as
         // type` converts into a `FacetAccessType`.
@@ -421,7 +421,10 @@ auto DeductionContext::Deduce() -> bool {
         // argument would be a facet value, whose type is the same facet type of
         // `G`. So here we "undo" the `as type` operation that's built into the
         // `g` parameter's type.
-        Add(access.facet_value_inst_id, arg_id);
+        //
+        // TODO: Look in ScopeStack with the the entity_name_id to find the
+        // facet value.
+        Add(binding.facet_value_inst_id, arg_id);
         continue;
       }
 

toolchain/check/eval.cpp

@@ -2174,15 +2174,70 @@ auto TryEvalTypedInst<SemIR::BindSymbolicName>(EvalContext& eval_context,
   return MakeConstantResult(eval_context.context(), bind, phase);
 }
 
+template <>
+auto TryEvalTypedInst<SemIR::SymbolicBindingType>(EvalContext& eval_context,
+                                                  SemIR::InstId inst_id,
+                                                  SemIR::Inst inst)
+    -> SemIR::ConstantId {
+  auto bind = inst.As<SemIR::SymbolicBindingType>();
+
+  Phase phase = Phase::Concrete;
+
+  // If we know which specific we're evaluating within and this is the type of
+  // an argument of that specific, its constant value refers to the type of the
+  // corresponding argument value.
+  const auto& bind_name = eval_context.entity_names().Get(bind.entity_name_id);
+  if (bind_name.bind_index().has_value()) {
+    if (auto value =
+            eval_context.GetCompileTimeBindValue(bind_name.bind_index());
+        value.has_value()) {
+      auto value_inst_id = eval_context.constant_values().GetInstId(value);
+      if (auto facet =
+              eval_context.insts().TryGetAs<SemIR::FacetValue>(value_inst_id)) {
+        // If the symbolic binding is replaced by a FacetValue (type + witness),
+        // evaluate to its type component.
+        return eval_context.constant_values().Get(facet->type_inst_id);
+      }
+
+      // Use the EntityNameId from the specific.
+      auto value_bind =
+          eval_context.insts().GetAs<SemIR::BindSymbolicName>(value_inst_id);
+      bind.entity_name_id =
+          GetConstantValue(eval_context, value_bind.entity_name_id, &phase);
+      inst = bind;
+    }
+  }
+
+  // Find the constant values of the fields other than the EntityNameId.
+  if (!ReplaceTypeWithConstantValue(eval_context, inst_id, &inst, &phase) ||
+      !ReplaceAllFieldsWithConstantValues(eval_context, &inst, &phase)) {
+    return SemIR::ConstantId::NotConstant;
+  }
+  // Propagate error phase after getting the constant value for all fields.
+  if (phase == Phase::UnknownDueToError) {
+    return SemIR::ErrorInst::ConstantId;
+  }
+
+  // Get the updated constant field values.
+  bind = inst.As<SemIR::SymbolicBindingType>();
+
+  // TODO: Look in ScopeStack with the the entity_name_id to find the facet
+  // value and get its constant value in the current specific context. The
+  // facet_value_inst_id will go away.
+  if (auto facet_value = eval_context.insts().TryGetAs<SemIR::FacetValue>(
+          bind.facet_value_inst_id)) {
+    return eval_context.constant_values().Get(facet_value->type_inst_id);
+  }
+
+  return MakeConstantResult(eval_context.context(), bind, phase);
+}
+
 // Returns whether `const_id` is the same constant facet value as
 // `facet_value_inst_id`.
 static auto IsSameFacetValue(Context& context, SemIR::ConstantId const_id,
                              SemIR::InstId facet_value_inst_id) -> bool {
-  if (auto facet_access_type = context.insts().TryGetAs<SemIR::FacetAccessType>(
-          context.constant_values().GetInstId(const_id))) {
-    const_id =
-        context.constant_values().Get(facet_access_type->facet_value_inst_id);
-  }
+  const_id = GetCanonicalizedFacetOrTypeValue(context, const_id,
+                                              /*preserve_facet_value=*/true);
   return const_id == context.constant_values().Get(facet_value_inst_id);
 }
 

toolchain/check/eval_inst.cpp

@@ -200,6 +200,20 @@ auto EvalConstantInst(Context& context, SemIR::FacetAccessType inst)
     return ConstantEvalResult::Existing(
         context.constant_values().Get(facet_value->type_inst_id));
   }
+
+  if (auto bind_name = context.insts().TryGetAs<SemIR::BindSymbolicName>(
+          inst.facet_value_inst_id)) {
+    return ConstantEvalResult::NewSamePhase(SemIR::SymbolicBindingType{
+        .type_id = SemIR::TypeType::TypeId,
+        .entity_name_id = bind_name->entity_name_id,
+        // TODO: This is to be removed, at which point replace NewSamePhase with
+        // NewAnyPhase.
+        .facet_value_inst_id = inst.facet_value_inst_id});
+  }
+
+  // Other instructions (e.g. ImplWitnessAccess) of type FacetType can appear
+  // here, in which case the constant inst is a FacetAccessType until those
+  // instructions resolve to one of the above.
   return ConstantEvalResult::NewSamePhase(inst);
 }
 

toolchain/check/impl_lookup.cpp

@@ -299,20 +299,6 @@ static auto GetWitnessIdForImpl(Context& context, SemIR::LocId loc_id,
   }
 }
 
-// Unwraps a FacetAccessType to move from a value of type `TypeType` to a facet
-// value of type `FacetType` if possible.
-//
-// Generally `GetCanonicalizedFacetOrTypeValue()` is what you want to call
-// instead, as this only does part of that operation, potentially returning a
-// non-canonical facet value.
-static auto UnwrapFacetAccessType(Context& context, SemIR::InstId inst_id)
-    -> SemIR::InstId {
-  if (auto access = context.insts().TryGetAs<SemIR::FacetAccessType>(inst_id)) {
-    return access->facet_value_inst_id;
-  }
-  return inst_id;
-}
-
 // Finds a lookup result from `query_self_inst_id` if it is a facet value that
 // names the query interface in its facet type. Note that `query_self_inst_id`
 // is allowed to be a non-canonical facet value in order to find a concrete
@@ -323,7 +309,8 @@ static auto LookupImplWitnessInSelfFacetValue(
   // Unwrap FacetAccessType without getting the canonical facet value from the
   // self value, as we want to preserve the non-canonical `FacetValue`
   // instruction which can contain the concrete witness.
-  query_self_inst_id = UnwrapFacetAccessType(context, query_self_inst_id);
+  query_self_inst_id = GetCanonicalizedFacetOrTypeValue(
+      context, query_self_inst_id, /*preserve_facet_value=*/true);
 
   auto facet_type = context.types().TryGetAs<SemIR::FacetType>(
       context.insts().Get(query_self_inst_id).type_id());

toolchain/check/import_ref.cpp

@@ -748,6 +748,8 @@ static auto GetLocalConstantId(ImportRefResolver& resolver,
 }
 
 // Translates a NameId from the import IR to a local NameId.
+//
+// No new work is generated by calling this function.
 static auto GetLocalNameId(ImportContext& context, SemIR::NameId import_name_id)
     -> SemIR::NameId {
   if (auto ident_id = import_name_id.AsIdentifierId(); ident_id.has_value()) {
@@ -757,6 +759,23 @@ static auto GetLocalNameId(ImportContext& context, SemIR::NameId import_name_id)
   return import_name_id;
 }
 
+// Returns the id for a local EntityName from an imported one, preserving only
+// the `NameId`, the `CompileTimeBindIndex`, and whether it is a template. Other
+// parts of the EntityName are not kept and are not considered part of the
+// canonical EntityName (even if they are present there).
+//
+// No new work is generated by calling this function.
+static auto GetLocalEntityNameId(ImportRefResolver& resolver,
+                                 SemIR::EntityNameId import_entity_name_id)
+    -> SemIR::EntityNameId {
+  const auto& import_entity_name =
+      resolver.import_entity_names().Get(import_entity_name_id);
+  auto name_id = GetLocalNameId(resolver, import_entity_name.name_id);
+  return resolver.local_entity_names().AddSymbolicBindingName(
+      name_id, SemIR::NameScopeId::None, import_entity_name.bind_index(),
+      import_entity_name.is_template);
+}
+
 // Gets the local constant values corresponding to an imported inst block.
 static auto GetLocalInstBlockContents(ImportRefResolver& resolver,
                                       SemIR::InstBlockId import_block_id)
@@ -1497,12 +1516,7 @@ static auto TryResolveTypedInst(ImportRefResolver& resolver,
     return ResolveResult::Retry();
   }
 
-  const auto& import_entity_name =
-      resolver.import_entity_names().Get(inst.entity_name_id);
-  auto name_id = GetLocalNameId(resolver, import_entity_name.name_id);
-  auto entity_name_id = resolver.local_entity_names().AddSymbolicBindingName(
-      name_id, SemIR::NameScopeId::None, import_entity_name.bind_index(),
-      import_entity_name.is_template);
+  auto entity_name_id = GetLocalEntityNameId(resolver, inst.entity_name_id);
   return ResolveAsDeduplicated<SemIR::BindSymbolicName>(
       resolver,
       {.type_id =
@@ -2942,6 +2956,22 @@ static auto TryResolveTypedInst(ImportRefResolver& resolver,
            GetLocalCanonicalInstBlockId(resolver, inst.elements_id, elems)});
 }
 
+static auto TryResolveTypedInst(ImportRefResolver& resolver,
+                                SemIR::SymbolicBindingType inst)
+    -> ResolveResult {
+  auto facet_value_inst_id =
+      GetLocalConstantInstId(resolver, inst.facet_value_inst_id);
+  if (resolver.HasNewWork()) {
+    return ResolveResult::Retry();
+  }
+
+  auto entity_name_id = GetLocalEntityNameId(resolver, inst.entity_name_id);
+  return ResolveAsDeduplicated<SemIR::SymbolicBindingType>(
+      resolver, {.type_id = SemIR::TypeType::TypeId,
+                 .entity_name_id = entity_name_id,
+                 .facet_value_inst_id = facet_value_inst_id});
+}
+
 static auto TryResolveTypedInst(ImportRefResolver& resolver,
                                 SemIR::TupleAccess inst) -> ResolveResult {
   auto type_id = GetLocalConstantId(resolver, inst.type_id);
@@ -3290,6 +3320,9 @@ static auto TryResolveInstCanonical(ImportRefResolver& resolver,
     case CARBON_KIND(SemIR::SymbolicBindingPattern inst): {
       return TryResolveTypedInst(resolver, inst, constant_inst_id);
     }
+    case CARBON_KIND(SemIR::SymbolicBindingType inst): {
+      return TryResolveTypedInst(resolver, inst);
+    }
     case CARBON_KIND(SemIR::TupleAccess inst): {
       return TryResolveTypedInst(resolver, inst);
     }

toolchain/check/member_access.cpp

@@ -321,11 +321,15 @@ static auto LookupMemberNameInScope(Context& context, SemIR::LocId loc_id,
           context.types().TryGetAs<SemIR::AssociatedEntityType>(type_id)) {
     if (lookup_in_type_of_base) {
       SemIR::TypeId base_type_id = context.insts().Get(base_id).type_id();
-      if (auto facet_access_type =
-              context.types().TryGetAs<SemIR::FacetAccessType>(base_type_id)) {
+      if (auto binding_type =
+              context.types().TryGetAs<SemIR::SymbolicBindingType>(
+                  base_type_id)) {
         // Move from the type of a symbolic facet value up in typish-ness to its
         // FacetType to find the type to work with.
-        base_id = facet_access_type->facet_value_inst_id;
+        //
+        // TODO: Look in ScopeStack with the the entity_name_id to find the
+        // facet value.
+        base_id = binding_type->facet_value_inst_id;
         base_type_id = context.insts().Get(base_id).type_id();
       }
 
@@ -612,9 +616,9 @@ static auto GetAssociatedValueImpl(Context& context, SemIR::LocId loc_id,
   }
   // That facet value has both the self type we need below and the witness
   // we are going to use to look up the value of the associated member.
-  auto self_type_const_id = TryEvalInst(
-      context, SemIR::FacetAccessType{.type_id = SemIR::TypeType::TypeId,
-                                      .facet_value_inst_id = facet_inst_id});
+  auto self_type_const_id = TryEvalInst<SemIR::FacetAccessType>(
+      context, {.type_id = SemIR::TypeType::TypeId,
+                .facet_value_inst_id = facet_inst_id});
   // TODO: We should be able to lookup constant associated values from runtime
   // facet values by using their FacetType only, but we assume constant values
   // for impl lookup at the moment.
@@ -625,6 +629,11 @@ static auto GetAssociatedValueImpl(Context& context, SemIR::LocId loc_id,
   auto self_type_id =
       context.types().GetTypeIdForTypeConstantId(self_type_const_id);
 
+  // TODO: If `ConvertToValueOfType` returned a `FacetValue`, we already got a
+  // witness for this interface there. We don't need to do both a
+  // ConvertToValueOfType and LookupImplWitness, that is redundant. Since we
+  // want to do LookupImplWitness unconditionally (eg. if `base_id` has exactly
+  // the right FacetType already), can we drop the ConvertToValueOfType step?
   auto lookup_result = LookupImplWitness(
       context, loc_id, context.constant_values().Get(facet_inst_id),
       EvalOrAddInst(context, loc_id,

toolchain/check/name_lookup.cpp

@@ -15,6 +15,7 @@
 #include "toolchain/diagnostics/format_providers.h"
 #include "toolchain/sem_ir/generic.h"
 #include "toolchain/sem_ir/name_scope.h"
+#include "toolchain/sem_ir/typed_insts.h"
 
 namespace Carbon::Check {
 
@@ -273,12 +274,15 @@ auto AppendLookupScopesForConstant(Context& context, SemIR::LocId loc_id,
   auto base_id = context.constant_values().GetInstId(base_const_id);
   auto base = context.insts().Get(base_id);
 
-  if (auto base_as_facet_access_type = base.TryAs<SemIR::FacetAccessType>()) {
+  if (auto base_as_binding_type = base.TryAs<SemIR::SymbolicBindingType>()) {
     // Move from the symbolic facet value up in typish-ness to its FacetType to
     // find a lookup scope.
+    //
+    // TODO: Look in ScopeStack with the the entity_name_id to find the
+    // facet value.
     auto facet_type_type_id =
         context.insts()
-            .Get(base_as_facet_access_type->facet_value_inst_id)
+            .Get(base_as_binding_type->facet_value_inst_id)
             .type_id();
     base_const_id = context.types().GetConstantId(facet_type_type_id);
     base_id = context.constant_values().GetInstId(base_const_id);