Replace InterfaceType with FacetType (#4499)

This does a few things:
* Replaces the single `TypeId` in the `FacetTypeInfo` struct with a
vector of `InterfaceId`, `SpecificId` pairs (sorted in id order)
representing the set of interface requirements of the facet type. This
will later be used to support facet types with multiple interface
requirements (as in `I & J` or `I where .Self impls J`).
* Replace `InterfaceType` instructions (used as the type of an
`InterfaceDecl` instruction) with `FacetType` instructions (introduced
in #4460) with a (newly introduced) `FacetTypeFromInterface()` function.
* Replace code that consumed `InterfaceType` values with code that
consumed `FaceType` values. I've generally left the assumption in the
code that it is dealing with a single interface, using the (newly
introduced) `FacetTypeInfo::TryAsSingleInterface`, and producing an
error otherwise. There isn't yet support for the `&` operator or `where
.Self impls`, so this is generally a good assumption for now, except you
can get a facet type with no associated interfaces from a `type
where`... expression. In some cases, the facet type value is pulled from
the evaluation of an `InterfaceDecl` instruction, where the single
interface assumption will hold permanently.
* Some related cleans up: nicer stringification and formatting of facet
types, suppression of some errors when there already was an error.

There is still a lot left to do, including:
* Type `type` should be a facet type with a reserved id, replacing the
built-in instruction.
* Code using `TryAsSingleInterface` should generally be upgraded to
handle more than (or less than) one interface. Name lookup should be
particularly exciting.
* Operator `&` should be defined on facet types, unioning their
interface and other requirements.
* Requirements from a `where` clause don't do anything yet.
* Impls and impl lookup need to resolve facet types, and do things like
determine if all the associated constants are given values.

---------

Co-authored-by: Josh L <[email protected]>
Co-authored-by: Geoff Romer <[email protected]>

Author: josh11b

toolchain/check/call.cpp

@@ -117,10 +117,8 @@ static auto PerformCallToGenericInterface(
   if (!callee_specific_id) {
     return SemIR::InstId::BuiltinError;
   }
-  return context.GetOrAddInst<SemIR::InterfaceType>(
-      loc_id, {.type_id = SemIR::TypeId::TypeType,
-               .interface_id = interface_id,
-               .specific_id = *callee_specific_id});
+  return context.GetOrAddInst(loc_id, context.FacetTypeFromInterface(
+                                          interface_id, *callee_specific_id));
 }
 
 auto PerformCall(Context& context, SemIR::LocId loc_id, SemIR::InstId callee_id,

toolchain/check/context.cpp

@@ -1069,12 +1069,10 @@ class TypeCompleter {
   }
 
   template <typename InstT>
-    requires(
-        InstT::Kind
-            .template IsAnyOf<SemIR::AssociatedEntityType, SemIR::FacetType,
-                              SemIR::FunctionType, SemIR::GenericClassType,
-                              SemIR::GenericInterfaceType, SemIR::InterfaceType,
-                              SemIR::UnboundElementType, SemIR::WhereExpr>())
+    requires(InstT::Kind.template IsAnyOf<
+             SemIR::AssociatedEntityType, SemIR::FacetType, SemIR::FunctionType,
+             SemIR::GenericClassType, SemIR::GenericInterfaceType,
+             SemIR::UnboundElementType, SemIR::WhereExpr>())
   auto BuildValueReprForInst(SemIR::TypeId /*type_id*/, InstT /*inst*/) const
       -> SemIR::ValueRepr {
     // These types have no runtime operations, so we use an empty value
@@ -1187,7 +1185,18 @@ auto Context::TryToDefineType(SemIR::TypeId type_id,
     return false;
   }
 
-  if (auto interface = types().TryGetAs<SemIR::InterfaceType>(type_id)) {
+  if (auto facet_type = types().TryGetAs<SemIR::FacetType>(type_id)) {
+    const auto& facet_type_info =
+        sem_ir().facet_types().Get(facet_type->facet_type_id);
+    auto interface = facet_type_info.TryAsSingleInterface();
+    if (!interface) {
+      auto builder = diagnoser();
+      CARBON_DIAGNOSTIC(SingleInterfaceFacetTypeOnly, Note,
+                        "only single interface facet types supported so far");
+      builder.Note(SemIR::LocId::Invalid, SingleInterfaceFacetTypeOnly);
+      builder.Emit();
+      return false;
+    }
     auto interface_id = interface->interface_id;
     if (!interfaces().Get(interface_id).is_defined()) {
       auto builder = diagnoser();
@@ -1218,6 +1227,16 @@ auto Context::GetTypeIdForTypeConstant(SemIR::ConstantId constant_id)
   return SemIR::TypeId::ForTypeConstant(constant_id);
 }
 
+auto Context::FacetTypeFromInterface(SemIR::InterfaceId interface_id,
+                                     SemIR::SpecificId specific_id)
+    -> SemIR::FacetType {
+  SemIR::FacetTypeId facet_type_id =
+      sem_ir().facet_types().Add(SemIR::FacetTypeInfo{
+          .impls_constraints = {{interface_id, specific_id}},
+          .requirement_block_id = SemIR::InstBlockId::Invalid});
+  return {.type_id = SemIR::TypeId::TypeType, .facet_type_id = facet_type_id};
+}
+
 // Gets or forms a type_id for a type, given the instruction kind and arguments.
 template <typename InstT, typename... EachArgT>
 static auto GetTypeImpl(Context& context, EachArgT... each_arg)

toolchain/check/context.h

@@ -361,9 +361,15 @@ class Context {
   // Returns whether `type_id` represents a facet type.
   auto IsFacetType(SemIR::TypeId type_id) -> bool {
     return type_id == SemIR::TypeId::TypeType ||
-           types().Is<SemIR::InterfaceType>(type_id);
+           types().Is<SemIR::FacetType>(type_id);
   }
 
+  // Create a FacetType typed instruction object consisting of a single
+  // interface.
+  auto FacetTypeFromInterface(SemIR::InterfaceId interface_id,
+                              SemIR::SpecificId specific_id)
+      -> SemIR::FacetType;
+
   // TODO: Consider moving these `Get*Type` functions to a separate class.
 
   // Gets the type for the name of an associated entity.

toolchain/check/convert.cpp

@@ -894,7 +894,7 @@ static auto PerformBuiltinConversion(Context& context, SemIR::LocId loc_id,
     // the case where F1 is an interface type and F2 is `type`.
     // TODO: Support converting tuple and struct values to facet types,
     // combining the above conversions and this one in a single conversion.
-    if (sem_ir.types().Is<SemIR::InterfaceType>(value_type_id)) {
+    if (sem_ir.types().Is<SemIR::FacetType>(value_type_id)) {
       return context.AddInst<SemIR::FacetTypeAccess>(
           loc_id, {.type_id = target.type_id, .facet_id = value_id});
     }

toolchain/check/deduce.cpp

@@ -114,13 +114,29 @@ class DeductionWorklist {
            needs_substitution);
   }
 
+  auto AddAll(SemIR::FacetTypeId params, SemIR::FacetTypeId args,
+              bool needs_substitution) -> void {
+    const auto& param_impls =
+        context_.sem_ir().facet_types().Get(params).impls_constraints;
+    const auto& arg_impls =
+        context_.sem_ir().facet_types().Get(args).impls_constraints;
+    if (param_impls.size() != arg_impls.size()) {
+      // TODO: Decide whether to error on this or just treat the parameter list
+      // as non-deduced. For now we treat it as non-deduced.
+      return;
+    }
+    for (auto [param, arg] :
+         llvm::reverse(llvm::zip_equal(param_impls, arg_impls))) {
+      Add(param.specific_id, arg.specific_id, needs_substitution);
+    }
+  }
+
   // Adds a (param, arg) pair for an instruction argument, given its kind.
   auto AddInstArg(SemIR::IdKind kind, int32_t param, int32_t arg,
                   bool needs_substitution) -> void {
     switch (kind) {
       case SemIR::IdKind::None:
       case SemIR::IdKind::For<SemIR::ClassId>:
-      case SemIR::IdKind::For<SemIR::InterfaceId>:
       case SemIR::IdKind::For<SemIR::IntKind>:
         break;
       case SemIR::IdKind::For<SemIR::InstId>:
@@ -145,6 +161,10 @@ class DeductionWorklist {
         Add(SemIR::SpecificId(param), SemIR::SpecificId(arg),
             needs_substitution);
         break;
+      case SemIR::IdKind::For<SemIR::FacetTypeId>:
+        AddAll(SemIR::FacetTypeId(param), SemIR::FacetTypeId(arg),
+               needs_substitution);
+        break;
       default:
         CARBON_FATAL("unexpected argument kind");
     }
@@ -400,8 +420,8 @@ auto DeductionContext::Deduce() -> bool {
       case SemIR::ArrayType::Kind:
       case SemIR::ClassType::Kind:
       case SemIR::ConstType::Kind:
+      case SemIR::FacetType::Kind:
       case SemIR::FloatType::Kind:
-      case SemIR::InterfaceType::Kind:
       case SemIR::IntType::Kind:
       case SemIR::PointerType::Kind:
       case SemIR::StructType::Kind:

toolchain/check/eval.cpp

@@ -391,6 +391,21 @@ static auto GetConstantValue(EvalContext& eval_context,
   return MakeSpecific(eval_context.context(), specific.generic_id, args_id);
 }
 
+// Like `GetConstantValue` but does a `FacetTypeId` -> `FacetTypeInfo`
+// conversion.
+static auto GetConstantFacetTypeInfo(EvalContext& eval_context,
+                                     SemIR::FacetTypeId facet_type_id,
+                                     Phase* phase) -> SemIR::FacetTypeInfo {
+  SemIR::FacetTypeInfo info = eval_context.facet_types().Get(facet_type_id);
+  for (auto& interface : info.impls_constraints) {
+    interface.specific_id =
+        GetConstantValue(eval_context, interface.specific_id, phase);
+  }
+  std::sort(info.impls_constraints.begin(), info.impls_constraints.end());
+  // TODO: Process & canonicalize other requirements.
+  return info;
+}
+
 // Replaces the specified field of the given typed instruction with its constant
 // value, if it has constant phase. Returns true on success, false if the value
 // has runtime phase.
@@ -1141,12 +1156,9 @@ static auto MakeConstantForCall(EvalContext& eval_context, SemIRLoc loc,
 
 // Creates a FacetType constant.
 static auto MakeFacetTypeResult(Context& context,
-                                SemIR::TypeId base_facet_type_id,
-                                SemIR::InstBlockId requirement_block_id,
-                                Phase phase) -> SemIR::ConstantId {
-  SemIR::FacetTypeId facet_type_id = context.sem_ir().facet_types().Add(
-      SemIR::FacetTypeInfo{.base_facet_type_id = base_facet_type_id,
-                           .requirement_block_id = requirement_block_id});
+                                const SemIR::FacetTypeInfo& info, Phase phase)
+    -> SemIR::ConstantId {
+  SemIR::FacetTypeId facet_type_id = context.sem_ir().facet_types().Add(info);
   return MakeConstantResult(context,
                             SemIR::FacetType{.type_id = SemIR::TypeId::TypeType,
                                              .facet_type_id = facet_type_id},
@@ -1230,9 +1242,6 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
       return RebuildIfFieldsAreConstant(
           eval_context, inst,
           &SemIR::GenericInterfaceType::enclosing_specific_id);
-    case SemIR::InterfaceType::Kind:
-      return RebuildIfFieldsAreConstant(eval_context, inst,
-                                        &SemIR::InterfaceType::specific_id);
     case SemIR::InterfaceWitness::Kind:
       return RebuildIfFieldsAreConstant(eval_context, inst,
                                         &SemIR::InterfaceWitness::elements_id);
@@ -1332,20 +1341,11 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     }
 
     case CARBON_KIND(SemIR::FacetType facet_type): {
-      SemIR::FacetTypeInfo info =
-          eval_context.facet_types().Get(facet_type.facet_type_id);
       Phase phase = Phase::Template;
-      SemIR::TypeId base_facet_type_id =
-          GetConstantValue(eval_context, info.base_facet_type_id, &phase);
-      // TODO: Process & canonicalize requirements.
-      SemIR::InstBlockId requirement_block_id = info.requirement_block_id;
-      // If nothing changed, can reuse this instruction.
-      if (base_facet_type_id == info.base_facet_type_id &&
-          requirement_block_id == info.requirement_block_id) {
-        return MakeConstantResult(eval_context.context(), inst, phase);
-      }
-      return MakeFacetTypeResult(eval_context.context(), base_facet_type_id,
-                                 requirement_block_id, phase);
+      SemIR::FacetTypeInfo info = GetConstantFacetTypeInfo(
+          eval_context, facet_type.facet_type_id, &phase);
+      // TODO: Reuse `inst` if we can detect that nothing has changed.
+      return MakeFacetTypeResult(eval_context.context(), info, phase);
     }
 
     case CARBON_KIND(SemIR::InterfaceDecl interface_decl): {
@@ -1363,12 +1363,11 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
             },
             &SemIR::InterfaceDecl::type_id);
       }
-      // A non-generic interface declaration evaluates to the interface type.
+      // A non-generic interface declaration evaluates to a facet type.
       return MakeConstantResult(
           eval_context.context(),
-          SemIR::InterfaceType{.type_id = SemIR::TypeId::TypeType,
-                               .interface_id = interface_decl.interface_id,
-                               .specific_id = SemIR::SpecificId::Invalid},
+          eval_context.context().FacetTypeFromInterface(
+              interface_decl.interface_id, SemIR::SpecificId::Invalid),
           Phase::Template);
     }
 
@@ -1506,15 +1505,28 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
       return eval_context.GetConstantValue(typed_inst.facet_id);
     }
     case CARBON_KIND(SemIR::WhereExpr typed_inst): {
+      Phase phase = Phase::Template;
       SemIR::TypeId base_facet_type_id =
           eval_context.insts().Get(typed_inst.period_self_id).type_id();
-      Phase phase = Phase::Template;
-      base_facet_type_id =
-          GetConstantValue(eval_context, base_facet_type_id, &phase);
-      SemIR::InstBlockId requirement_block_id = typed_inst.requirements_id;
-      // TODO: Process & canonicalize requirements.
-      return MakeFacetTypeResult(eval_context.context(), base_facet_type_id,
-                                 requirement_block_id, phase);
+      SemIR::Inst base_facet_inst =
+          eval_context.GetConstantValueAsInst(base_facet_type_id);
+      SemIR::FacetTypeInfo info = {.requirement_block_id =
+                                       SemIR::InstBlockId::Invalid};
+      // `where` provides that the base facet is an error, `type`, or a facet
+      // type.
+      if (auto facet_type = base_facet_inst.TryAs<SemIR::FacetType>()) {
+        info = GetConstantFacetTypeInfo(eval_context, facet_type->facet_type_id,
+                                        &phase);
+      } else if (base_facet_type_id == SemIR::TypeId::Error) {
+        return SemIR::ConstantId::Error;
+      } else {
+        CARBON_CHECK(base_facet_type_id == SemIR::TypeId::TypeType,
+                     "Unexpected type_id: {0}, inst: {1}", base_facet_type_id,
+                     base_facet_inst);
+      }
+      // TODO: Combine other requirements, and then process & canonicalize them.
+      info.requirement_block_id = typed_inst.requirements_id;
+      return MakeFacetTypeResult(eval_context.context(), info, phase);
     }
 
     // `not true` -> `false`, `not false` -> `true`.

toolchain/check/handle_impl.cpp

@@ -173,10 +173,18 @@ static auto ExtendImpl(Context& context, Parse::NodeId extend_node,
     diag.Emit();
   }
 
-  auto interface_type =
-      context.types().TryGetAs<SemIR::InterfaceType>(constraint_id);
+  auto facet_type = context.types().TryGetAs<SemIR::FacetType>(constraint_id);
+  if (!facet_type) {
+    context.TODO(node_id, "extending non-facet-type constraint");
+    parent_scope.has_error = true;
+    return;
+  }
+  const SemIR::FacetTypeInfo& info =
+      context.sem_ir().facet_types().Get(facet_type->facet_type_id);
+
+  auto interface_type = info.TryAsSingleInterface();
   if (!interface_type) {
-    context.TODO(node_id, "extending non-interface constraint");
+    context.TODO(node_id, "extending non-single-interface facet type");
     parent_scope.has_error = true;
     return;
   }

toolchain/check/handle_index.cpp

@@ -34,7 +34,7 @@ static auto GetIndexWithArgs(Context& context, Parse::NodeId node_id,
   auto index_with_inst_id = context.LookupNameInCore(node_id, "IndexWith");
   // If the `IndexWith` interface doesn't have generic arguments then return an
   // empty reference.
-  if (context.insts().Is<SemIR::InterfaceType>(index_with_inst_id)) {
+  if (context.insts().Is<SemIR::FacetType>(index_with_inst_id)) {
     return llvm::ArrayRef<SemIR::InstId>();
   }
 
@@ -59,12 +59,17 @@ static auto GetIndexWithArgs(Context& context, Parse::NodeId node_id,
     if (impl_self_type_id != self_id) {
       continue;
     }
-    auto interface_type =
-        context.types().TryGetAs<SemIR::InterfaceType>(impl_constraint_type_id);
+    auto facet_type =
+        context.types().TryGetAs<SemIR::FacetType>(impl_constraint_type_id);
+    if (!facet_type) {
+      continue;
+    }
+    const auto& facet_type_info =
+        context.sem_ir().facet_types().Get(facet_type->facet_type_id);
+    auto interface_type = facet_type_info.TryAsSingleInterface();
     if (!interface_type) {
       continue;
     }
-
     if (index_with_interface->interface_id != interface_type->interface_id) {
       continue;
     }

toolchain/check/handle_interface.cpp

@@ -160,12 +160,10 @@ auto HandleParseNode(Context& context,
 
   // Declare and introduce `Self`.
   if (!interface_info.is_defined()) {
-    auto interface_type =
-        SemIR::InterfaceType{.type_id = SemIR::TypeId::TypeType,
-                             .interface_id = interface_id,
-                             .specific_id = self_specific_id};
+    SemIR::FacetType facet_type =
+        context.FacetTypeFromInterface(interface_id, self_specific_id);
     SemIR::TypeId self_type_id = context.GetTypeIdForTypeConstant(
-        TryEvalInst(context, SemIR::InstId::Invalid, interface_type));
+        TryEvalInst(context, SemIR::InstId::Invalid, facet_type));
 
     // We model `Self` as a symbolic binding whose type is the interface.
     // Because there is no equivalent non-symbolic value, we use `Invalid` as

toolchain/check/handle_where.cpp

@@ -16,7 +16,8 @@ auto HandleParseNode(Context& context, Parse::WhereOperandId node_id) -> bool {
   auto [self_node, self_id] = context.node_stack().PopExprWithNodeId();
   auto self_type_id = ExprAsType(context, self_node, self_id).type_id;
   // Only facet types may have `where` restrictions.
-  if (!context.IsFacetType(self_type_id)) {
+  if (self_type_id != SemIR::TypeId::Error &&
+      !context.IsFacetType(self_type_id)) {
     CARBON_DIAGNOSTIC(WhereOnNonFacetType, Error,
                       "left argument of `where` operator must be a facet type");
     context.emitter().Emit(self_node, WhereOnNonFacetType);