Initial support for binding patterns in SemIR

toolchain/check/BUILD

@@ -29,6 +29,7 @@ cc_library(
         "merge.cpp",
         "modifiers.cpp",
         "name_component.cpp",
+        "pattern_block_stack.cpp",
         "return.cpp",
         "subst.cpp",
     ],
@@ -51,6 +52,7 @@ cc_library(
         "modifiers.h",
         "name_component.h",
         "param_and_arg_refs_stack.h",
+        "pattern_block_stack.h",
         "pending_block.h",
         "return.h",
         "subst.h",

toolchain/check/context.cpp

@@ -48,6 +48,7 @@ Context::Context(const Lex::TokenizedBuffer& tokens, DiagnosticEmitter& emitter,
       vlog_stream_(vlog_stream),
       node_stack_(parse_tree, vlog_stream),
       inst_block_stack_("inst_block_stack_", sem_ir, vlog_stream),
+      pattern_block_stack_(this),
       param_and_arg_refs_stack_(sem_ir, vlog_stream, node_stack_),
       args_type_info_stack_("args_type_info_stack_", sem_ir, vlog_stream),
       decl_name_stack_(this),
@@ -147,6 +148,13 @@ auto Context::AddPlaceholderInst(SemIR::LocIdAndInst loc_id_and_inst)
   return inst_id;
 }
 
+auto Context::AddPatternInst(SemIR::LocIdAndInst loc_id_and_inst)
+    -> SemIR::InstId {
+  auto inst_id = sem_ir().insts().AddInNoBlock(loc_id_and_inst);
+  pattern_block_stack_.AddInst(inst_id);
+  return inst_id;
+}
+
 auto Context::AddConstant(SemIR::Inst inst, bool is_symbolic)
     -> SemIR::ConstantId {
   auto const_id = constants().GetOrAdd(inst, is_symbolic);

toolchain/check/context.h

@@ -16,6 +16,7 @@
 #include "toolchain/check/inst_block_stack.h"
 #include "toolchain/check/node_stack.h"
 #include "toolchain/check/param_and_arg_refs_stack.h"
+#include "toolchain/check/pattern_block_stack.h"
 #include "toolchain/check/scope_stack.h"
 #include "toolchain/parse/node_ids.h"
 #include "toolchain/parse/tree.h"
@@ -112,6 +113,18 @@ class Context {
   auto AddPlaceholderInstInNoBlock(SemIR::LocIdAndInst loc_id_and_inst)
       -> SemIR::InstId;
 
+  // Adds an instruction to the current pattern block, returning the produced
+  // ID.
+  auto AddPatternInst(SemIR::LocIdAndInst loc_id_and_inst) -> SemIR::InstId;
+
+  // Convenience for AddPatternInst with typed nodes.
+  template <typename InstT>
+    requires(SemIR::Internal::HasNodeId<InstT>)
+  auto AddPatternInst(decltype(InstT::Kind)::TypedNodeId node_id, InstT inst)
+      -> SemIR::InstId {
+    return AddPatternInst(SemIR::LocIdAndInst(node_id, inst));
+  }
+
   // Adds an instruction to the constants block, returning the produced ID.
   auto AddConstant(SemIR::Inst inst, bool is_symbolic) -> SemIR::ConstantId;
 
@@ -392,6 +405,9 @@ class Context {
   auto node_stack() -> NodeStack& { return node_stack_; }
 
   auto inst_block_stack() -> InstBlockStack& { return inst_block_stack_; }
+  auto pattern_block_stack() -> PatternBlockStack& {
+    return pattern_block_stack_;
+  }
 
   auto param_and_arg_refs_stack() -> ParamAndArgRefsStack& {
     return param_and_arg_refs_stack_;
@@ -529,6 +545,9 @@ class Context {
   // The stack of instruction blocks being used for general IR generation.
   InstBlockStack inst_block_stack_;
 
+  // The stack of instruction blocks that contain pattern instructions.
+  PatternBlockStack pattern_block_stack_;
+
   // The stack of instruction blocks being used for param and arg ref blocks.
   ParamAndArgRefsStack param_and_arg_refs_stack_;
 

toolchain/check/eval.cpp

@@ -1468,6 +1468,7 @@ auto TryEvalInstInContext(EvalContext& eval_context, SemIR::InstId inst_id,
     case SemIR::AddrPattern::Kind:
     case SemIR::Assign::Kind:
     case SemIR::BindName::Kind:
+    case SemIR::BindingPattern::Kind:
     case SemIR::BlockArg::Kind:
     case SemIR::Branch::Kind:
     case SemIR::BranchIf::Kind:
@@ -1478,6 +1479,7 @@ auto TryEvalInstInContext(EvalContext& eval_context, SemIR::InstId inst_id,
     case SemIR::ReturnExpr::Kind:
     case SemIR::Return::Kind:
     case SemIR::StructLiteral::Kind:
+    case SemIR::SymbolicBindingPattern::Kind:
     case SemIR::TupleLiteral::Kind:
     case SemIR::VarStorage::Kind:
       break;

toolchain/check/handle_alias.cpp

@@ -16,11 +16,15 @@ auto HandleParseNode(Context& context, Parse::AliasIntroducerId /*node_id*/)
     -> bool {
   context.decl_introducer_state_stack().Push<Lex::TokenKind::Alias>();
   context.decl_name_stack().PushScopeAndStartName();
+  context.pattern_block_stack().Push();
   return true;
 }
 
-auto HandleParseNode(Context& /*context*/,
-                     Parse::AliasInitializerId /*node_id*/) -> bool {
+auto HandleParseNode(Context& context, Parse::AliasInitializerId /*node_id*/)
+    -> bool {
+  // TODO: when/if parameterized aliases are supported, this must be
+  // attached to the `BindAlias` inst.
+  (void)context.pattern_block_stack().Pop();
   return true;
 }
 

toolchain/check/handle_binding_pattern.cpp

@@ -163,6 +163,20 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
       // TODO: Bindings should come into scope immediately in other contexts
       // too.
       context.AddNameToLookup(name_id, bind_id);
+      auto entity_name_id =
+          context.insts().GetAs<SemIR::AnyBindName>(bind_id).entity_name_id;
+      if (is_generic) {
+        context.AddPatternInst<SemIR::SymbolicBindingPattern>(
+            name_node,
+            {.type_id = cast_type_id, .entity_name_id = entity_name_id});
+      } else {
+        context.AddPatternInst<SemIR::BindingPattern>(
+            name_node,
+            {.type_id = cast_type_id, .entity_name_id = entity_name_id});
+      }
+      // TODO: use the pattern insts to generate the pattern-match insts
+      // at the end of the full pattern, instead of eagerly generating them
+      // here.
       break;
     }
 

toolchain/check/handle_class.cpp

@@ -41,6 +41,8 @@ auto HandleParseNode(Context& context, Parse::ClassIntroducerId node_id)
   context.decl_name_stack().PushScopeAndStartName();
   // This class is potentially generic.
   StartGenericDecl(context);
+  // Start a new pattern block for the signature.
+  context.pattern_block_stack().Push();
   return true;
 }
 
@@ -208,12 +210,15 @@ static auto BuildClassDecl(Context& context, Parse::AnyClassDeclId node_id,
           ? SemIR::Class::Base
           : SemIR::Class::Final;
 
+  SemIR::InstBlockId pattern_block_id = context.pattern_block_stack().Pop();
   auto decl_block_id = context.inst_block_stack().Pop();
+  SemIR::DeclId decl_id = context.sem_ir().decls().Add(
+      {.pattern_block_id = pattern_block_id, .decl_block_id = decl_block_id});
 
   // Add the class declaration.
   auto class_decl = SemIR::ClassDecl{.type_id = SemIR::TypeId::TypeType,
                                      .class_id = SemIR::ClassId::Invalid,
-                                     .decl_block_id = decl_block_id};
+                                     .decl_id = decl_id};
   auto class_decl_id =
       context.AddPlaceholderInst(SemIR::LocIdAndInst(node_id, class_decl));
 

toolchain/check/handle_export.cpp

@@ -18,10 +18,17 @@ auto HandleParseNode(Context& context, Parse::ExportIntroducerId /*node_id*/)
   context.decl_introducer_state_stack().Push<Lex::TokenKind::Export>();
   // TODO: Probably need to update DeclNameStack to restrict to only namespaces.
   context.decl_name_stack().PushScopeAndStartName();
+  // The parser supports patterns after `export`, so we need a pattern block
+  // to handle them.
+  context.pattern_block_stack().Push();
   return true;
 }
 
 auto HandleParseNode(Context& context, Parse::ExportDeclId node_id) -> bool {
+  // Discard the pattern block, because patterns after `export` are disallowed,
+  // and diagnosed elsewhere.
+  (void)context.pattern_block_stack().Pop();
+
   auto name_context = context.decl_name_stack().FinishName(
       PopNameComponentWithoutParams(context, Lex::TokenKind::Export));
   context.decl_name_stack().PopScope();

toolchain/check/handle_function.cpp

@@ -34,6 +34,8 @@ auto HandleParseNode(Context& context, Parse::FunctionIntroducerId node_id)
   context.decl_name_stack().PushScopeAndStartName();
   // The function is potentially generic.
   StartGenericDecl(context);
+  // Start a new pattern block for the signature.
+  context.pattern_block_stack().Push();
   return true;
 }
 
@@ -171,8 +173,6 @@ static auto BuildFunctionDecl(Context& context,
                               Parse::AnyFunctionDeclId node_id,
                               bool is_definition)
     -> std::pair<SemIR::FunctionId, SemIR::InstId> {
-  auto decl_block_id = context.inst_block_stack().Pop();
-
   auto return_storage_id = SemIR::InstId::Invalid;
   if (auto [return_node, maybe_return_storage_id] =
           context.node_stack().PopWithNodeIdIf<Parse::NodeKind::ReturnType>();
@@ -209,48 +209,56 @@ static auto BuildFunctionDecl(Context& context,
   }
 
   // Add the function declaration.
-  auto function_decl = SemIR::FunctionDecl{
-      SemIR::TypeId::Invalid, SemIR::FunctionId::Invalid, decl_block_id};
-  auto decl_id =
+  auto pattern_block_id = context.pattern_block_stack().Pop();
+  auto decl_block_id = context.inst_block_stack().Pop();
+  SemIR::DeclId decl_id = context.sem_ir().decls().Add({
+      .pattern_block_id = pattern_block_id,
+      .decl_block_id = decl_block_id,
+  });
+  SemIR::FunctionDecl function_decl = {
+      .type_id = SemIR::TypeId::Invalid,
+      .function_id = SemIR::FunctionId::Invalid,
+      .decl_id = decl_id};
+  auto decl_inst_id =
       context.AddPlaceholderInst(SemIR::LocIdAndInst(node_id, function_decl));
 
   // Build the function entity. This will be merged into an existing function if
   // there is one, or otherwise added to the function store.
   auto function_info = SemIR::Function{
-      {name_context.MakeEntityWithParamsBase(name, decl_id, is_extern)},
+      {name_context.MakeEntityWithParamsBase(name, decl_inst_id, is_extern)},
       {.return_storage_id = return_storage_id}};
   if (is_definition) {
-    function_info.definition_id = decl_id;
+    function_info.definition_id = decl_inst_id;
   }
 
   TryMergeRedecl(context, node_id, name_context.prev_inst_id(), function_decl,
                  function_info, is_definition);
 
   // Create a new function if this isn't a valid redeclaration.
   if (!function_decl.function_id.is_valid()) {
-    function_info.generic_id = FinishGenericDecl(context, decl_id);
+    function_info.generic_id = FinishGenericDecl(context, decl_inst_id);
     function_decl.function_id = context.functions().Add(function_info);
   } else {
-    FinishGenericRedecl(context, decl_id, function_info.generic_id);
+    FinishGenericRedecl(context, decl_inst_id, function_info.generic_id);
     // TODO: Validate that the redeclaration doesn't set an access modifier.
   }
   function_decl.type_id = context.GetFunctionType(
       function_decl.function_id, context.scope_stack().PeekSpecificId());
 
   // Write the function ID into the FunctionDecl.
-  context.ReplaceInstBeforeConstantUse(decl_id, function_decl);
+  context.ReplaceInstBeforeConstantUse(decl_inst_id, function_decl);
 
   // Check if we need to add this to name lookup, now that the function decl is
   // done.
   if (!name_context.prev_inst_id().is_valid()) {
     // At interface scope, a function declaration introduces an associated
     // function.
-    auto lookup_result_id = decl_id;
+    auto lookup_result_id = decl_inst_id;
     if (parent_scope_inst && !name_context.has_qualifiers) {
       if (auto interface_scope =
               parent_scope_inst->TryAs<SemIR::InterfaceDecl>()) {
         lookup_result_id = BuildAssociatedEntity(
-            context, interface_scope->interface_id, decl_id);
+            context, interface_scope->interface_id, decl_inst_id);
       }
     }
 
@@ -276,10 +284,10 @@ static auto BuildFunctionDecl(Context& context,
   }
 
   if (!is_definition && context.IsImplFile() && !is_extern) {
-    context.definitions_required().push_back(decl_id);
+    context.definitions_required().push_back(decl_inst_id);
   }
 
-  return {function_decl.function_id, decl_id};
+  return {function_decl.function_id, decl_inst_id};
 }
 
 auto HandleParseNode(Context& context, Parse::FunctionDeclId node_id) -> bool {

toolchain/check/handle_impl.cpp

@@ -30,6 +30,10 @@ auto HandleParseNode(Context& context, Parse::ImplIntroducerId node_id)
   // consistent to imagine that it does. This also gives us a scope for implicit
   // parameters.
   context.decl_name_stack().PushScopeAndStartName();
+
+  // Push a pattern block for the signature.
+  context.pattern_block_stack().Push();
+
   return true;
 }
 
@@ -184,9 +188,12 @@ static auto BuildImplDecl(Context& context, Parse::AnyImplDeclId node_id,
       context.node_stack().PopExprWithNodeId();
   auto [self_type_node, self_type_id] =
       context.node_stack().PopWithNodeId<Parse::NodeCategory::ImplAs>();
+  SemIR::InstBlockId pattern_block_id = context.pattern_block_stack().Pop();
   auto [params_node, params_id] =
       context.node_stack().PopWithNodeIdIf<Parse::NodeKind::ImplForall>();
   auto decl_block_id = context.inst_block_stack().Pop();
+  SemIR::DeclId decl_id = context.sem_ir().decls().Add(
+      {.pattern_block_id = pattern_block_id, .decl_block_id = decl_block_id});
   context.node_stack().PopForSoloNodeId<Parse::NodeKind::ImplIntroducer>();
 
   // Convert the constraint expression to a type.
@@ -214,8 +221,7 @@ static auto BuildImplDecl(Context& context, Parse::AnyImplDeclId node_id,
   // TODO: Does lookup in an impl file need to look for a prior impl declaration
   // in the api file?
   auto impl_id = context.impls().LookupOrAdd(self_type_id, constraint_type_id);
-  SemIR::ImplDecl impl_decl = {.impl_id = impl_id,
-                               .decl_block_id = decl_block_id};
+  SemIR::ImplDecl impl_decl = {.impl_id = impl_id, .decl_id = decl_id};
   auto impl_decl_id = context.AddInst(node_id, impl_decl);
 
   // For an `extend impl` declaration, mark the impl as extending this `impl`.

toolchain/check/handle_interface.cpp

@@ -25,6 +25,8 @@ auto HandleParseNode(Context& context, Parse::InterfaceIntroducerId node_id)
   context.decl_name_stack().PushScopeAndStartName();
   // This interface is potentially generic.
   StartGenericDecl(context);
+  // Push a pattern block for the signature.
+  context.pattern_block_stack().Push();
   return true;
 }
 
@@ -45,11 +47,14 @@ static auto BuildInterfaceDecl(Context& context,
   CheckAccessModifiersOnDecl(context, introducer, parent_scope_inst);
   LimitModifiersOnDecl(context, introducer, KeywordModifierSet::Access);
 
+  SemIR::InstBlockId pattern_block_id = context.pattern_block_stack().Pop();
   auto decl_block_id = context.inst_block_stack().Pop();
+  SemIR::DeclId decl_id = context.sem_ir().decls().Add(
+      {.pattern_block_id = pattern_block_id, .decl_block_id = decl_block_id});
 
   // Add the interface declaration.
   auto interface_decl = SemIR::InterfaceDecl{
-      SemIR::TypeId::TypeType, SemIR::InterfaceId::Invalid, decl_block_id};
+      SemIR::TypeId::TypeType, SemIR::InterfaceId::Invalid, decl_id};
   auto interface_decl_id =
       context.AddPlaceholderInst(SemIR::LocIdAndInst(node_id, interface_decl));
 

toolchain/check/handle_let_and_var.cpp

@@ -19,8 +19,9 @@ namespace Carbon::Check {
 template <Lex::TokenKind::RawEnumType Kind>
 static auto HandleIntroducer(Context& context, Parse::NodeId node_id) -> bool {
   context.decl_introducer_state_stack().Push<Kind>();
-  // Push a bracketing node to establish the pattern context.
+  // Push a bracketing node and pattern block to establish the pattern context.
   context.node_stack().Push(node_id);
+  context.pattern_block_stack().Push();
   return true;
 }
 
@@ -145,6 +146,11 @@ template <const Lex::TokenKind& IntroducerTokenKind,
 static auto HandleDecl(Context& context, NodeT node_id)
     -> std::optional<DeclInfo> {
   std::optional<DeclInfo> decl_info = DeclInfo();
+
+  // TODO: update binding-pattern handling to use the pattern block even in
+  // a let/var context, and then consume it here.
+  (void)context.pattern_block_stack().Pop();
+
   // Handle the optional initializer.
   if (context.node_stack().PeekNextIs<InitializerNodeKind>()) {
     decl_info->init_id = context.node_stack().PopExpr();

toolchain/check/handle_namespace.cpp

@@ -18,10 +18,14 @@ auto HandleParseNode(Context& context, Parse::NamespaceStartId /*node_id*/)
   // Optional modifiers and the name follow.
   context.decl_introducer_state_stack().Push<Lex::TokenKind::Namespace>();
   context.decl_name_stack().PushScopeAndStartName();
+  context.pattern_block_stack().Push();
   return true;
 }
 
 auto HandleParseNode(Context& context, Parse::NamespaceId node_id) -> bool {
+  // TODO: consume this when/if parameterized namespaces are supported.
+  (void)context.pattern_block_stack().Pop();
+
   auto name_context = context.decl_name_stack().FinishName(
       PopNameComponentWithoutParams(context, Lex::TokenKind::Namespace));