Add the .Self name for the type expression of a compile time binding (#5937)

We add a virtual node (`CompileTimeBindingPatternStart`) as the first
child of `CompileTimeBindingPattern` which holds the identifier
underneath it, so that it is checked just before the type expression of
the `CompileTimeBindingPattern`. When we reach this virtual node during
check, we add `.Self` as a name in the current scope, and when we reach
`CompileTimeBindingPattern` we remove it from scope, which ensures it's
present during only the checking of the type expression for the compile
time pattern.

At the moment the `.Self` has a different type (it's a `TypeType`) than
other `.Self` in the facet type (which are a single `FacetType`), but
the intention is to immediately substitute it out of the facet type
entirely, replacing it with a reference to the compile time binding (a
`BindSymbolicName`) itself. A TODO has been added for this.

---------

Co-authored-by: Jon Ross-Perkins <[email protected]>

Author: danakj

toolchain/check/facet_type.cpp

@@ -614,4 +614,26 @@ auto ResolveFacetTypeRewriteConstraints(
   return true;
 }
 
+auto MakePeriodSelfFacetValue(Context& context, SemIR::TypeId self_type_id)
+    -> SemIR::InstId {
+  auto entity_name_id = context.entity_names().AddCanonical({
+      .name_id = SemIR::NameId::PeriodSelf,
+      .parent_scope_id = context.scope_stack().PeekNameScopeId(),
+  });
+  auto inst_id = AddInst(
+      context, SemIR::LocIdAndInst::NoLoc<SemIR::BindSymbolicName>({
+                   .type_id = self_type_id,
+                   .entity_name_id = entity_name_id,
+                   // `None` because there is no equivalent non-symbolic value.
+                   .value_id = SemIR::InstId::None,
+               }));
+  // TODO: LookupOrAddName should (optionally?) take a callback to run and
+  // construct the `inst_id` only if it's not found by lookup.
+  auto existing =
+      context.scope_stack().LookupOrAddName(SemIR::NameId::PeriodSelf, inst_id);
+  // Shouldn't have any names in newly created scope.
+  CARBON_CHECK(!existing.has_value());
+  return inst_id;
+}
+
 }  // namespace Carbon::Check

toolchain/check/facet_type.h

@@ -95,6 +95,14 @@ auto ResolveFacetTypeRewriteConstraints(
     llvm::SmallVector<SemIR::FacetTypeInfo::RewriteConstraint>& rewrites)
     -> bool;
 
+// Introduce `.Self` as a symbolic binding into the current scope, and return
+// the `BindSymbolicName` instruction.
+//
+// The `self_type_id` is either a facet type (as `FacetType`) or `type` (as
+// `TypeType`).
+auto MakePeriodSelfFacetValue(Context& context, SemIR::TypeId self_type_id)
+    -> SemIR::InstId;
+
 }  // namespace Carbon::Check
 
 #endif  // CARBON_TOOLCHAIN_CHECK_FACET_TYPE_H_

toolchain/check/handle_binding_pattern.cpp

@@ -4,6 +4,7 @@
 
 #include "toolchain/check/context.h"
 #include "toolchain/check/convert.h"
+#include "toolchain/check/facet_type.h"
 #include "toolchain/check/handle.h"
 #include "toolchain/check/inst.h"
 #include "toolchain/check/interface.h"
@@ -57,6 +58,12 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
         AddBindingPattern(context, name_node, name_id, cast_type_id,
                           type_expr_region_id, is_generic, is_template);
 
+    // TODO: If `is_generic`, then `binding.bind_id is a BindSymbolicName. Subst
+    // the `.Self` of type `type` in the `cast_type_id` type (a `FacetType`)
+    // with the `binding.bind_id` itself, and build a new pattern with that.
+    // This is kind of cyclical. So we need to reuse the EntityNameId, which
+    // will also reuse the CompileTimeBinding for the new BindSymbolicName.
+
     if (name_id != SemIR::NameId::Underscore) {
       // Add name to lookup immediately, so it can be used in the rest of the
       // enclosing pattern.
@@ -273,11 +280,28 @@ auto HandleParseNode(Context& context, Parse::VarBindingPatternId node_id)
                                  Parse::NodeKind::VarBindingPattern);
 }
 
+auto HandleParseNode(Context& context,
+                     Parse::CompileTimeBindingPatternStartId /*node_id*/)
+    -> bool {
+  // Make a scope to contain the `.Self` facet value for use in the type of the
+  // compile time binding. This is popped when handling the
+  // CompileTimeBindingPatternId.
+  context.scope_stack().PushForSameRegion();
+  MakePeriodSelfFacetValue(context, SemIR::TypeType::TypeId);
+  return true;
+}
+
 auto HandleParseNode(Context& context,
                      Parse::CompileTimeBindingPatternId node_id) -> bool {
+  // Pop the `.Self` facet value name introduced by the
+  // CompileTimeBindingPatternStart.
+  context.scope_stack().Pop();
+
   auto node_kind = Parse::NodeKind::CompileTimeBindingPattern;
-  if (context.decl_introducer_state_stack().innermost().kind ==
-      Lex::TokenKind::Let) {
+
+  const DeclIntroducerState& introducer =
+      context.decl_introducer_state_stack().innermost();
+  if (introducer.kind == Lex::TokenKind::Let) {
     // Disallow `let` outside of function and interface definitions.
     // TODO: Find a less brittle way of doing this. A `scope_inst_id` of `None`
     // can represent a block scope, but is also used for other kinds of scopes

toolchain/check/handle_where.cpp

@@ -54,24 +54,8 @@ auto HandleParseNode(Context& context, Parse::WhereOperandId node_id) -> bool {
   context.scope_stack().PushForSameRegion();
   // Introduce `.Self` as a symbolic binding. Its type is the value of the
   // expression to the left of `where`, so `MyInterface` in the example above.
-  //
-  // It uses the `Self` type _without_ any constraints so that the `Self` is the
-  // same at all levels of a nested facet type such as:
-  //   `(Z where .X = {}) where .X = {}`.
-  auto entity_name_id = context.entity_names().AddCanonical(
-      {.name_id = SemIR::NameId::PeriodSelf,
-       .parent_scope_id = context.scope_stack().PeekNameScopeId()});
-  auto period_self_inst_id = AddInst(
-      context, SemIR::LocIdAndInst::NoLoc<SemIR::BindSymbolicName>({
-                   .type_id = self_without_constraints_type_id,
-                   .entity_name_id = entity_name_id,
-                   // `None` because there is no equivalent non-symbolic value.
-                   .value_id = SemIR::InstId::None,
-               }));
-  auto existing = context.scope_stack().LookupOrAddName(
-      SemIR::NameId::PeriodSelf, period_self_inst_id);
-  // Shouldn't have any names in newly created scope.
-  CARBON_CHECK(!existing.has_value());
+  auto period_self_inst_id =
+      MakePeriodSelfFacetValue(context, self_without_constraints_type_id);
 
   // Save the `.Self` symbolic binding on the node stack. It will become the
   // first argument to the `WhereExpr` instruction.

toolchain/check/node_stack.h

@@ -479,6 +479,7 @@ class NodeStack {
       case Parse::NodeKind::CallExprComma:
       case Parse::NodeKind::ChoiceAlternativeListComma:
       case Parse::NodeKind::CodeBlock:
+      case Parse::NodeKind::CompileTimeBindingPatternStart:
       case Parse::NodeKind::ContinueStatementStart:
       case Parse::NodeKind::CorePackageName:
       case Parse::NodeKind::ExportIntroducer: