Initial support for empty named constraints (#6245)

Type check named constraint decls and definitions. We don't correctly
error if you put a `fn` inside them. There is no support for `require`
or `alias` yet, so there's nothing useful you can do with them yet.

We have attempted to share code between `interface` and `constraint` as
they are quite similar. First by splitting out some of
handle_interface.cpp to a separate file. Second by sharing some code
paths when you want a facet type from either one, as they both turn into
a facet type.

Author: danakj

toolchain/check/call.cpp

@@ -116,24 +116,42 @@ static auto PerformCallToGenericClass(Context& context, SemIR::LocId loc_id,
                                          .specific_id = *callee_specific_id});
 }
 
-// Performs a call where the callee is the name of a generic interface, such as
-// `AddWith(i32)`.
-static auto PerformCallToGenericInterface(
-    Context& context, SemIR::LocId loc_id, SemIR::InterfaceId interface_id,
+static auto EntityFromInterfaceOrNamedConstraint(
+    Context& context, SemIR::InterfaceId interface_id)
+    -> const SemIR::EntityWithParamsBase& {
+  return context.interfaces().Get(interface_id);
+}
+
+static auto EntityFromInterfaceOrNamedConstraint(
+    Context& context, SemIR::NamedConstraintId named_constraint_id)
+    -> const SemIR::EntityWithParamsBase& {
+  return context.named_constraints().Get(named_constraint_id);
+}
+
+// Performs a call where the callee is the name of a generic interface or named
+// constraint, such as `AddWith(i32)`.
+template <typename IdT>
+  requires SameAsOneOf<IdT, SemIR::InterfaceId, SemIR::NamedConstraintId>
+static auto PerformCallToGenericInterfaceOrNamedConstaint(
+    Context& context, SemIR::LocId loc_id, IdT id,
     SemIR::SpecificId enclosing_specific_id,
     llvm::ArrayRef<SemIR::InstId> arg_ids) -> SemIR::InstId {
-  const auto& interface = context.interfaces().Get(interface_id);
+  const auto& entity = EntityFromInterfaceOrNamedConstraint(context, id);
   auto callee_specific_id =
-      ResolveCalleeInCall(context, loc_id, interface,
-                          EntityKind::GenericInterface, enclosing_specific_id,
+      ResolveCalleeInCall(context, loc_id, entity, EntityKind::GenericInterface,
+                          enclosing_specific_id,
                           /*self_type_id=*/SemIR::InstId::None,
                           /*self_id=*/SemIR::InstId::None, arg_ids);
   if (!callee_specific_id) {
     return SemIR::ErrorInst::InstId;
   }
-  return GetOrAddInst(
-      context, loc_id,
-      FacetTypeFromInterface(context, interface_id, *callee_specific_id));
+  std::optional<SemIR::FacetType> facet_type;
+  if constexpr (std::same_as<IdT, SemIR::InterfaceId>) {
+    facet_type = FacetTypeFromInterface(context, id, *callee_specific_id);
+  } else {
+    facet_type = FacetTypeFromNamedConstraint(context, id, *callee_specific_id);
+  }
+  return GetOrAddInst(context, loc_id, *facet_type);
 }
 
 // Builds an appropriate specific function for the callee, also handling
@@ -307,10 +325,15 @@ static auto PerformCallToNonFunction(Context& context, SemIR::LocId loc_id,
                                        arg_ids);
     }
     case CARBON_KIND(SemIR::GenericInterfaceType generic_interface): {
-      return PerformCallToGenericInterface(
+      return PerformCallToGenericInterfaceOrNamedConstaint(
           context, loc_id, generic_interface.interface_id,
           generic_interface.enclosing_specific_id, arg_ids);
     }
+    case CARBON_KIND(SemIR::GenericNamedConstraintType generic_constraint): {
+      return PerformCallToGenericInterfaceOrNamedConstaint(
+          context, loc_id, generic_constraint.named_constraint_id,
+          generic_constraint.enclosing_specific_id, arg_ids);
+    }
     default: {
       CARBON_DIAGNOSTIC(CallToNonCallable, Error,
                         "value of type {0} is not callable", TypeOfInstId);

toolchain/check/context.h

@@ -265,6 +265,9 @@ class Context {
   auto classes() -> SemIR::ClassStore& { return sem_ir().classes(); }
   auto vtables() -> SemIR::VtableStore& { return sem_ir().vtables(); }
   auto interfaces() -> SemIR::InterfaceStore& { return sem_ir().interfaces(); }
+  auto named_constraints() -> SemIR::NamedConstraintStore& {
+    return sem_ir().named_constraints();
+  }
   auto associated_constants() -> SemIR::AssociatedConstantStore& {
     return sem_ir().associated_constants();
   }

toolchain/check/eval_inst.cpp

@@ -451,6 +451,25 @@ auto EvalConstantInst(Context& context, SemIR::InterfaceDecl inst)
       context.generics().GetSelfSpecific(interface_info.generic_id)));
 }
 
+auto EvalConstantInst(Context& context, SemIR::NamedConstraintDecl inst)
+    -> ConstantEvalResult {
+  const auto& named_constraint_info =
+      context.named_constraints().Get(inst.named_constraint_id);
+
+  // If the named constraint has generic parameters, we don't produce a named
+  // constraint type, but a callable whose return value is a named constraint
+  // type.
+  if (named_constraint_info.has_parameters()) {
+    return ConstantEvalResult::NewSamePhase(SemIR::StructValue{
+        .type_id = inst.type_id, .elements_id = SemIR::InstBlockId::Empty});
+  }
+
+  // A non-parameterized named constraint declaration evaluates to a facet type.
+  return ConstantEvalResult::NewAnyPhase(FacetTypeFromNamedConstraint(
+      context, inst.named_constraint_id,
+      context.generics().GetSelfSpecific(named_constraint_info.generic_id)));
+}
+
 auto EvalConstantInst(Context& context, SemIR::NameRef inst)
     -> ConstantEvalResult {
   // A name reference evaluates to the value the name resolves to.

toolchain/check/facet_type.cpp

@@ -8,6 +8,7 @@
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "toolchain/base/kind_switch.h"
 #include "toolchain/check/convert.h"
 #include "toolchain/check/diagnostic_helpers.h"
 #include "toolchain/check/generic.h"
@@ -24,8 +25,23 @@ namespace Carbon::Check {
 
 auto FacetTypeFromInterface(Context& context, SemIR::InterfaceId interface_id,
                             SemIR::SpecificId specific_id) -> SemIR::FacetType {
-  auto info =
-      SemIR::FacetTypeInfo{.extend_constraints = {{interface_id, specific_id}}};
+  auto info = SemIR::FacetTypeInfo{};
+
+  info.extend_constraints.push_back({interface_id, specific_id});
+  // TODO: Add `require impls` to the set of constraints.
+
+  info.Canonicalize();
+  SemIR::FacetTypeId facet_type_id = context.facet_types().Add(info);
+  return {.type_id = SemIR::TypeType::TypeId, .facet_type_id = facet_type_id};
+}
+
+auto FacetTypeFromNamedConstraint(
+    Context& context, SemIR::NamedConstraintId /*named_constraint_id*/,
+    SemIR::SpecificId /*specific_id*/) -> SemIR::FacetType {
+  auto info = SemIR::FacetTypeInfo{};
+
+  // TODO: Add `require impls` to the set of constraints.
+
   info.Canonicalize();
   SemIR::FacetTypeId facet_type_id = context.facet_types().Add(info);
   return {.type_id = SemIR::TypeType::TypeId, .facet_type_id = facet_type_id};

toolchain/check/facet_type.h

@@ -8,16 +8,27 @@
 #include <compare>
 
 #include "toolchain/check/context.h"
+#include "toolchain/sem_ir/entity_with_params_base.h"
 #include "toolchain/sem_ir/ids.h"
 
 namespace Carbon::Check {
 
-// Create a FacetType typed instruction object consisting of a single
-// interface. The `specific_id` specifies arguments in the case the interface is
-// generic.
+// Create a FacetType typed instruction object consisting of a interface. The
+// `specific_id` specifies arguments in the case the interface is generic.
+//
+// The resulting FacetType may contain multiple interfaces if the named
+// interface contains `require` declarations.
 auto FacetTypeFromInterface(Context& context, SemIR::InterfaceId interface_id,
                             SemIR::SpecificId specific_id) -> SemIR::FacetType;
 
+// Create a FacetType typed instruction object consisting of a named constraint.
+// The `specific_id` specifies arguments in the case the named constraint is
+// generic.
+auto FacetTypeFromNamedConstraint(Context& context,
+                                  SemIR::NamedConstraintId named_constraint_id,
+                                  SemIR::SpecificId specific_id)
+    -> SemIR::FacetType;
+
 // Given an ImplWitnessAccessSubstituted, returns the InstId of the
 // ImplWitnessAccess. Otherwise, returns the input `inst_id` unchanged.
 //

toolchain/check/generic.cpp

@@ -730,7 +730,7 @@ auto ResolveSpecificDefinition(Context& context, SemIR::LocId loc_id,
 }
 
 auto DiagnoseIfGenericMissingExplicitParameters(
-    Context& context, SemIR::EntityWithParamsBase& entity_base) -> void {
+    Context& context, const SemIR::EntityWithParamsBase& entity_base) -> void {
   if (!entity_base.implicit_param_patterns_id.has_value() ||
       entity_base.param_patterns_id.has_value()) {
     return;

toolchain/check/generic.h

@@ -123,7 +123,7 @@ auto ResolveSpecificDefinition(Context& context, SemIR::LocId loc_id,
 // Diagnoses if an entity has implicit parameters, indicating it's generic, but
 // is missing explicit parameters.
 auto DiagnoseIfGenericMissingExplicitParameters(
-    Context& context, SemIR::EntityWithParamsBase& entity_base) -> void;
+    Context& context, const SemIR::EntityWithParamsBase& entity_base) -> void;
 
 }  // namespace Carbon::Check
 

toolchain/check/handle_interface.cpp

@@ -10,11 +10,15 @@
 #include "toolchain/check/generic.h"
 #include "toolchain/check/handle.h"
 #include "toolchain/check/inst.h"
+#include "toolchain/check/interface.h"
 #include "toolchain/check/merge.h"
 #include "toolchain/check/modifiers.h"
 #include "toolchain/check/name_component.h"
 #include "toolchain/check/name_lookup.h"
 #include "toolchain/check/type.h"
+#include "toolchain/sem_ir/entity_with_params_base.h"
+#include "toolchain/sem_ir/ids.h"
+#include "toolchain/sem_ir/interface.h"
 #include "toolchain/sem_ir/typed_insts.h"
 
 namespace Carbon::Check {
@@ -26,11 +30,12 @@ auto HandleParseNode(Context& context, Parse::InterfaceIntroducerId node_id)
   // Create an instruction block to hold the instructions created as part of the
   // interface signature, such as generic parameters.
   context.inst_block_stack().Push();
-  // Push the bracketing node.
-  context.node_stack().Push(node_id);
   // Optional modifiers and the name follow.
   context.decl_introducer_state_stack().Push<Lex::TokenKind::Interface>();
   context.decl_name_stack().PushScopeAndStartName();
+
+  // Push the bracketing node.
+  context.node_stack().Push(node_id);
   return true;
 }
 
@@ -56,87 +61,44 @@ static auto BuildInterfaceDecl(Context& context,
   // Add the interface declaration.
   auto interface_decl = SemIR::InterfaceDecl{
       SemIR::TypeType::TypeId, SemIR::InterfaceId::None, decl_block_id};
-  auto interface_decl_id = AddPlaceholderInst(context, node_id, interface_decl);
+  auto decl_inst_id = AddPlaceholderInst(context, node_id, interface_decl);
 
   SemIR::Interface interface_info = {name_context.MakeEntityWithParamsBase(
-      name, interface_decl_id, /*is_extern=*/false,
-      SemIR::LibraryNameId::None)};
+      name, decl_inst_id, /*is_extern=*/false, SemIR::LibraryNameId::None)};
 
   DiagnoseIfGenericMissingExplicitParameters(context, interface_info);
 
   // Check whether this is a redeclaration.
   SemIR::ScopeLookupResult lookup_result =
       context.decl_name_stack().LookupOrAddName(
-          name_context, interface_decl_id,
-          introducer.modifier_set.GetAccessKind());
-  if (lookup_result.is_poisoned()) {
-    // This is a declaration of a poisoned name.
-    DiagnosePoisonedName(context, name_context.name_id_for_new_inst(),
-                         lookup_result.poisoning_loc_id(), name_context.loc_id);
-  } else if (lookup_result.is_found()) {
-    SemIR::InstId existing_id = lookup_result.target_inst_id();
-    if (auto existing_interface_decl =
-            context.insts().Get(existing_id).TryAs<SemIR::InterfaceDecl>()) {
-      auto existing_interface =
-          context.interfaces().Get(existing_interface_decl->interface_id);
-      if (CheckRedeclParamsMatch(
-              context,
-              DeclParams(SemIR::LocId(interface_decl_id),
-                         name.first_param_node_id, name.last_param_node_id,
-                         name.implicit_param_patterns_id,
-                         name.param_patterns_id),
-              DeclParams(existing_interface))) {
-        // TODO: This should be refactored a little, particularly for
-        // prev_import_ir_id. See similar logic for classes and functions, which
-        // might also be refactored to merge.
-        DiagnoseIfInvalidRedecl(
-            context, Lex::TokenKind::Interface, existing_interface.name_id,
-            RedeclInfo(interface_info, node_id, is_definition),
-            RedeclInfo(existing_interface,
-                       SemIR::LocId(existing_interface.latest_decl_id()),
-                       existing_interface.has_definition_started()),
-            /*prev_import_ir_id=*/SemIR::ImportIRId::None);
-
-        // Can't merge interface definitions due to the generic requirements.
-        if (!is_definition || !existing_interface.has_definition_started()) {
-          // This is a redeclaration of an existing interface.
-          interface_decl.interface_id = existing_interface_decl->interface_id;
-          interface_decl.type_id = existing_interface_decl->type_id;
-          // TODO: If the new declaration is a definition, keep its parameter
-          // and implicit parameter lists rather than the ones from the
-          // previous declaration.
-        }
-      }
-    } else {
-      // This is a redeclaration of something other than a interface.
-      DiagnoseDuplicateName(context, name_context.name_id, name_context.loc_id,
-                            SemIR::LocId(existing_id));
-    }
-  }
+          name_context, decl_inst_id, introducer.modifier_set.GetAccessKind());
+  if (auto existing_decl = TryGetExistingDecl(context, name, lookup_result,
+                                              interface_info, is_definition)) {
+    auto existing_interface_decl = existing_decl->As<SemIR::InterfaceDecl>();
+    interface_decl.interface_id = existing_interface_decl.interface_id;
+    interface_decl.type_id = existing_interface_decl.type_id;
+    // TODO: If the new declaration is a definition, keep its parameter
+    // and implicit parameter lists rather than the ones from the
+    // previous declaration.
 
-  // Create a new interface if this isn't a valid redeclaration.
-  if (!interface_decl.interface_id.has_value()) {
-    // TODO: If this is an invalid redeclaration of a non-interface entity or
-    // there was an error in the qualifier, we will have lost track of the
-    // interface name here. We should keep track of it even if the name is
-    // invalid.
-    interface_info.generic_id = BuildGenericDecl(context, interface_decl_id);
+    auto prev_decl_generic_id =
+        context.interfaces().Get(interface_decl.interface_id).generic_id;
+    FinishGenericRedecl(context, prev_decl_generic_id);
+  } else {
+    // Create a new interface if this isn't a valid redeclaration.
+    interface_info.generic_id = BuildGenericDecl(context, decl_inst_id);
     interface_decl.interface_id = context.interfaces().Add(interface_info);
     if (interface_info.has_parameters()) {
       interface_decl.type_id =
           GetGenericInterfaceType(context, interface_decl.interface_id,
                                   context.scope_stack().PeekSpecificId());
     }
-  } else {
-    auto prev_decl_generic_id =
-        context.interfaces().Get(interface_decl.interface_id).generic_id;
-    FinishGenericRedecl(context, prev_decl_generic_id);
   }
 
   // Write the interface ID into the InterfaceDecl.
-  ReplaceInstBeforeConstantUse(context, interface_decl_id, interface_decl);
+  ReplaceInstBeforeConstantUse(context, decl_inst_id, interface_decl);
 
-  return {interface_decl.interface_id, interface_decl_id};
+  return {interface_decl.interface_id, decl_inst_id};
 }
 
 auto HandleParseNode(Context& context, Parse::InterfaceDeclId node_id) -> bool {
@@ -147,16 +109,16 @@ auto HandleParseNode(Context& context, Parse::InterfaceDeclId node_id) -> bool {
 
 auto HandleParseNode(Context& context,
                      Parse::InterfaceDefinitionStartId node_id) -> bool {
-  auto [interface_id, interface_decl_id] =
+  auto [interface_id, decl_inst_id] =
       BuildInterfaceDecl(context, node_id, /*is_definition=*/true);
   auto& interface_info = context.interfaces().Get(interface_id);
 
   // Track that this declaration is the definition.
   CARBON_CHECK(!interface_info.has_definition_started(),
                "Can't merge with defined interfaces.");
-  interface_info.definition_id = interface_decl_id;
+  interface_info.definition_id = decl_inst_id;
   interface_info.scope_id = context.name_scopes().Add(
-      interface_decl_id, SemIR::NameId::None, interface_info.parent_scope_id);
+      decl_inst_id, SemIR::NameId::None, interface_info.parent_scope_id);
   context.name_scopes()
       .Get(interface_info.scope_id)
       .set_is_interface_definition();
@@ -167,35 +129,21 @@ auto HandleParseNode(Context& context,
   StartGenericDefinition(context, interface_info.generic_id);
 
   context.inst_block_stack().Push();
-  context.node_stack().Push(node_id, interface_id);
 
   // We use the arg stack to build the witness table type.
   context.args_type_info_stack().Push();
 
-  // Declare and introduce `Self`.
+  // Declare and introduce `Self`. We model `Self` as a symbolic binding whose
+  // type is the interface, excluding any other interfaces mentioned by
+  // `require` declarations.
   SemIR::TypeId self_type_id =
       GetInterfaceType(context, interface_id, self_specific_id);
-
-  // We model `Self` as a symbolic binding whose type is the interface.
-  // Because there is no equivalent non-symbolic value, we use `None` as
-  // the `value_id` on the `BindSymbolicName`.
-  auto entity_name_id = context.entity_names().AddSymbolicBindingName(
-      SemIR::NameId::SelfType, interface_info.scope_id,
-      context.scope_stack().AddCompileTimeBinding(),
-      /*is_template=*/false);
-  interface_info.self_param_id =
-      AddInst(context, SemIR::LocIdAndInst::NoLoc<SemIR::BindSymbolicName>(
-                           {.type_id = self_type_id,
-                            .entity_name_id = entity_name_id,
-                            .value_id = SemIR::InstId::None}));
-  context.scope_stack().PushCompileTimeBinding(interface_info.self_param_id);
-  context.name_scopes().AddRequiredName(interface_info.scope_id,
-                                        SemIR::NameId::SelfType,
-                                        interface_info.self_param_id);
+  interface_info.self_param_id = AddSelfGenericParameter(
+      context, self_type_id, interface_info.scope_id, /*is_template=*/false);
 
   // Enter the interface scope.
-  context.scope_stack().PushForEntity(
-      interface_decl_id, interface_info.scope_id, self_specific_id);
+  context.scope_stack().PushForEntity(decl_inst_id, interface_info.scope_id,
+                                      self_specific_id);
 
   // TODO: Handle the case where there's control flow in the interface body. For
   // example:
@@ -207,6 +155,8 @@ auto HandleParseNode(Context& context,
   // We may need to track a list of instruction blocks here, as we do for a
   // function.
   interface_info.body_block_id = context.inst_block_stack().PeekOrAdd();
+
+  context.node_stack().Push(node_id, interface_id);
   return true;
 }