Generate parameter pattern-match IR from pattern IR (#4388)

Also propagate the pattern IR along with the pattern-match IR, and use
it where appropriate.

Strictly speaking, some parts of the pattern-match IR are allocated
eagerly, while traversing the pattern's parse tree, but they still
aren't actually emitted until we traverse the associated pattern insts.

---------

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

Author: geoffromer

toolchain/check/BUILD

@@ -32,6 +32,7 @@ cc_library(
         "modifiers.cpp",
         "name_component.cpp",
         "operator.cpp",
+        "pattern_match.cpp",
         "return.cpp",
         "subst.cpp",
     ],
@@ -57,6 +58,7 @@ cc_library(
         "name_component.h",
         "operator.h",
         "param_and_arg_refs_stack.h",
+        "pattern_match.h",
         "pending_block.h",
         "return.h",
         "subst.h",

toolchain/check/call.cpp

@@ -61,8 +61,8 @@ static auto ResolveCalleeInCall(Context& context, SemIR::LocId loc_id,
   if (entity_generic_id.is_valid()) {
     specific_id = DeduceGenericCallArguments(
         context, loc_id, entity_generic_id, enclosing_specific_id,
-        callee_info.implicit_param_refs_id, callee_info.param_refs_id, self_id,
-        arg_ids);
+        callee_info.implicit_param_patterns_id, callee_info.param_patterns_id,
+        self_id, arg_ids);
     if (!specific_id.is_valid()) {
       return std::nullopt;
     }

toolchain/check/context.cpp

@@ -921,6 +921,7 @@ class TypeCompleter {
       -> SemIR::ValueRepr {
     switch (builtin.builtin_inst_kind) {
       case SemIR::BuiltinInstKind::TypeType:
+      case SemIR::BuiltinInstKind::AutoType:
       case SemIR::BuiltinInstKind::Error:
       case SemIR::BuiltinInstKind::Invalid:
       case SemIR::BuiltinInstKind::BoolType:

toolchain/check/convert.cpp

@@ -13,6 +13,7 @@
 #include "toolchain/base/kind_switch.h"
 #include "toolchain/check/context.h"
 #include "toolchain/check/operator.h"
+#include "toolchain/check/pattern_match.h"
 #include "toolchain/sem_ir/copy_on_write_block.h"
 #include "toolchain/sem_ir/file.h"
 #include "toolchain/sem_ir/generic.h"
@@ -1138,9 +1139,8 @@ CARBON_DIAGNOSTIC(InCallToFunction, Note, "calling function declared here");
 static auto ConvertSelf(Context& context, SemIR::LocId call_loc_id,
                         SemIRLoc callee_loc,
                         SemIR::SpecificId callee_specific_id,
-                        std::optional<SemIR::AddrPattern> addr_pattern,
-                        SemIR::InstId self_param_id, SemIR::Param self_param,
-                        SemIR::InstId self_id) -> SemIR::InstId {
+                        SemIR::InstId self_param_id, SemIR::InstId self_id)
+    -> SemIR::InstId {
   if (!self_id.is_valid()) {
     CARBON_DIAGNOSTIC(MissingObjectInMethodCall, Error,
                       "missing object argument in method call");
@@ -1151,6 +1151,7 @@ static auto ConvertSelf(Context& context, SemIR::LocId call_loc_id,
     return SemIR::InstId::BuiltinError;
   }
 
+  bool addr_pattern = context.insts().Is<SemIR::AddrPattern>(self_param_id);
   DiagnosticAnnotationScope annotate_diagnostics(
       &context.emitter(), [&](auto& builder) {
         CARBON_DIAGNOSTIC(
@@ -1162,69 +1163,46 @@ static auto ConvertSelf(Context& context, SemIR::LocId call_loc_id,
                                   : llvm::StringLiteral("self"));
       });
 
-  // For `addr self`, take the address of the object argument.
-  auto self_or_addr_id = self_id;
-  if (addr_pattern) {
-    self_or_addr_id = ConvertToValueOrRefExpr(context, self_or_addr_id);
-    auto self = context.insts().Get(self_or_addr_id);
-    switch (SemIR::GetExprCategory(context.sem_ir(), self_id)) {
-      case SemIR::ExprCategory::Error:
-      case SemIR::ExprCategory::DurableRef:
-      case SemIR::ExprCategory::EphemeralRef:
-        break;
-      default:
-        CARBON_DIAGNOSTIC(AddrSelfIsNonRef, Error,
-                          "`addr self` method cannot be invoked on a value");
-        context.emitter().Emit(TokenOnly(call_loc_id), AddrSelfIsNonRef);
-        return SemIR::InstId::BuiltinError;
-    }
-    auto loc_id = context.insts().GetLocId(self_or_addr_id);
-    self_or_addr_id = context.AddInst<SemIR::AddrOf>(
-        loc_id, {.type_id = context.GetPointerType(self.type_id()),
-                 .lvalue_id = self_or_addr_id});
-  }
-
-  return ConvertToValueOfType(
-      context, call_loc_id, self_or_addr_id,
-      SemIR::GetTypeInSpecific(context.sem_ir(), callee_specific_id,
-                               self_param.type_id));
+  return CallerPatternMatch(context, callee_specific_id, self_param_id,
+                            self_id);
 }
 
+// TODO: consider moving this to pattern_match.h
 auto ConvertCallArgs(Context& context, SemIR::LocId call_loc_id,
                      SemIR::InstId self_id,
                      llvm::ArrayRef<SemIR::InstId> arg_refs,
                      SemIR::InstId return_storage_id,
                      const CalleeParamsInfo& callee,
                      SemIR::SpecificId callee_specific_id)
     -> SemIR::InstBlockId {
-  auto implicit_param_refs =
-      context.inst_blocks().GetOrEmpty(callee.implicit_param_refs_id);
-  auto param_refs = context.inst_blocks().GetOrEmpty(callee.param_refs_id);
+  auto implicit_param_patterns =
+      context.inst_blocks().GetOrEmpty(callee.implicit_param_patterns_id);
+  auto param_patterns =
+      context.inst_blocks().GetOrEmpty(callee.param_patterns_id);
 
   // The caller should have ensured this callee has the right arity.
-  CARBON_CHECK(arg_refs.size() == param_refs.size());
+  CARBON_CHECK(arg_refs.size() == param_patterns.size());
 
   // Start building a block to hold the converted arguments.
   llvm::SmallVector<SemIR::InstId> args;
-  args.reserve(implicit_param_refs.size() + param_refs.size() +
+  args.reserve(implicit_param_patterns.size() + param_patterns.size() +
                return_storage_id.is_valid());
 
   // Check implicit parameters.
-  for (auto implicit_param_id : implicit_param_refs) {
-    auto addr_pattern =
-        context.insts().TryGetAs<SemIR::AddrPattern>(implicit_param_id);
-    auto param_info = SemIR::Function::GetParamFromParamRefId(
+  for (auto implicit_param_id : implicit_param_patterns) {
+    auto param_pattern_info = SemIR::Function::GetParamPatternInfoFromPatternId(
         context.sem_ir(), implicit_param_id);
-    if (param_info.GetNameId(context.sem_ir()) == SemIR::NameId::SelfValue) {
-      auto converted_self_id = ConvertSelf(
-          context, call_loc_id, callee.callee_loc, callee_specific_id,
-          addr_pattern, param_info.inst_id, param_info.inst, self_id);
+    if (param_pattern_info.GetNameId(context.sem_ir()) ==
+        SemIR::NameId::SelfValue) {
+      auto converted_self_id =
+          ConvertSelf(context, call_loc_id, callee.callee_loc,
+                      callee_specific_id, implicit_param_id, self_id);
       if (converted_self_id == SemIR::InstId::BuiltinError) {
         return SemIR::InstBlockId::Invalid;
       }
       args.push_back(converted_self_id);
     } else {
-      CARBON_CHECK(!param_info.inst.runtime_index.is_valid(),
+      CARBON_CHECK(!param_pattern_info.inst.runtime_index.is_valid(),
                    "Unexpected implicit parameter passed at runtime");
     }
   }
@@ -1240,31 +1218,25 @@ auto ConvertCallArgs(Context& context, SemIR::LocId call_loc_id,
       });
 
   // Check type conversions per-element.
-  for (auto [i, arg_id, param_ref_id] : llvm::enumerate(arg_refs, param_refs)) {
+  for (auto [i, arg_id, param_pattern_id] :
+       llvm::enumerate(arg_refs, param_patterns)) {
     diag_param_index = i;
 
-    // TODO: In general we need to perform pattern matching here to find the
-    // argument corresponding to each parameter.
-    auto param_info =
-        SemIR::Function::GetParamFromParamRefId(context.sem_ir(), param_ref_id);
-    if (!param_info.inst.runtime_index.is_valid()) {
+    auto runtime_index = SemIR::Function::GetParamPatternInfoFromPatternId(
+                             context.sem_ir(), param_pattern_id)
+                             .inst.runtime_index;
+    if (!runtime_index.is_valid()) {
       // Not a runtime parameter: we don't pass an argument.
       continue;
     }
 
-    auto param_type_id = SemIR::GetTypeInSpecific(
-        context.sem_ir(), callee_specific_id,
-        context.insts().Get(param_info.inst_id).type_id());
-    // TODO: Convert to the proper expression category. For now, we assume
-    // parameters are all `let` bindings.
-    auto converted_arg_id =
-        ConvertToValueOfType(context, call_loc_id, arg_id, param_type_id);
+    auto converted_arg_id = CallerPatternMatch(context, callee_specific_id,
+                                               param_pattern_id, arg_id);
     if (converted_arg_id == SemIR::InstId::BuiltinError) {
       return SemIR::InstBlockId::Invalid;
     }
 
-    CARBON_CHECK(static_cast<int32_t>(args.size()) ==
-                     param_info.inst.runtime_index.index,
+    CARBON_CHECK(static_cast<int32_t>(args.size()) == runtime_index.index,
                  "Parameters not numbered in order.");
     args.push_back(converted_arg_id);
   }

toolchain/check/convert.h

@@ -97,14 +97,18 @@ struct CalleeParamsInfo {
   explicit CalleeParamsInfo(const SemIR::EntityWithParamsBase& callee)
       : callee_loc(callee.latest_decl_id()),
         implicit_param_refs_id(callee.implicit_param_refs_id),
-        param_refs_id(callee.param_refs_id) {}
+        implicit_param_patterns_id(callee.implicit_param_patterns_id),
+        param_refs_id(callee.param_refs_id),
+        param_patterns_id(callee.param_patterns_id) {}
 
   // The location of the callee to use in diagnostics.
   SemIRLoc callee_loc;
   // The implicit parameters of the callee.
   SemIR::InstBlockId implicit_param_refs_id;
+  SemIR::InstBlockId implicit_param_patterns_id;
   // The explicit parameters of the callee.
   SemIR::InstBlockId param_refs_id;
+  SemIR::InstBlockId param_patterns_id;
 };
 
 // Implicitly converts a set of arguments to match the parameter types in a

toolchain/check/decl_name_stack.cpp

@@ -377,9 +377,9 @@ auto DeclNameStack::ResolveAsScope(const NameContext& name_context,
     return InvalidResult;
   }
 
-  auto new_params = DeclParams(name.name_loc_id, name.first_param_node_id,
-                               name.last_param_node_id, name.implicit_params_id,
-                               name.params_id);
+  auto new_params = DeclParams(
+      name.name_loc_id, name.first_param_node_id, name.last_param_node_id,
+      name.implicit_param_patterns_id, name.param_patterns_id);
 
   // Find the scope corresponding to the resolved instruction.
   // TODO: When diagnosing qualifiers on names, print a diagnostic that talks

toolchain/check/decl_name_stack.h

@@ -102,7 +102,9 @@ class DeclNameStack {
           .last_param_node_id = name.last_param_node_id,
           .pattern_block_id = name.pattern_block_id,
           .implicit_param_refs_id = name.implicit_params_id,
+          .implicit_param_patterns_id = name.implicit_param_patterns_id,
           .param_refs_id = name.params_id,
+          .param_patterns_id = name.param_patterns_id,
           .is_extern = is_extern,
           .extern_library_id = extern_library,
           .non_owning_decl_id =

toolchain/check/deduce.cpp

@@ -282,8 +282,16 @@ auto DeductionContext::Deduce() -> bool {
     CARBON_KIND_SWITCH(param_inst) {
       // Deducing a symbolic binding from an argument with a constant value
       // deduces the binding as having that constant value.
-      case CARBON_KIND(SemIR::BindSymbolicName bind): {
-        auto& entity_name = context().entity_names().Get(bind.entity_name_id);
+      case SemIR::InstKind::SymbolicBindingPattern:
+      case SemIR::InstKind::BindSymbolicName: {
+        auto entity_name_id = SemIR::EntityNameId::Invalid;
+        if (auto bind = param_inst.TryAs<SemIR::SymbolicBindingPattern>()) {
+          entity_name_id = bind->entity_name_id;
+        } else {
+          entity_name_id =
+              param_inst.As<SemIR::BindSymbolicName>().entity_name_id;
+        }
+        auto& entity_name = context().entity_names().Get(entity_name_id);
         auto index = entity_name.bind_index;
         if (!index.is_valid() || index < first_deduced_index_) {
           break;

toolchain/check/eval.cpp

@@ -1360,6 +1360,28 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     case SemIR::ValueAsRef::Kind:
       break;
 
+    case CARBON_KIND(SemIR::SymbolicBindingPattern bind): {
+      // TODO: disable constant evaluation of SymbolicBindingPattern once
+      // DeduceGenericCallArguments no longer needs implicit params to have
+      // constant values.
+      const auto& bind_name =
+          eval_context.entity_names().Get(bind.entity_name_id);
+
+      // If we know which specific we're evaluating within and this is an
+      // argument of that specific, its constant value is the corresponding
+      // argument value.
+      if (auto value =
+              eval_context.GetCompileTimeBindValue(bind_name.bind_index);
+          value.is_valid()) {
+        return value;
+      }
+
+      // The constant form of a symbolic binding is an idealized form of the
+      // original, with no equivalent value.
+      bind.entity_name_id =
+          eval_context.entity_names().MakeCanonical(bind.entity_name_id);
+      return MakeConstantResult(eval_context.context(), bind, Phase::Symbolic);
+    }
     case CARBON_KIND(SemIR::BindSymbolicName bind): {
       const auto& bind_name =
           eval_context.entity_names().Get(bind.entity_name_id);
@@ -1394,6 +1416,9 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     case CARBON_KIND(SemIR::NameRef typed_inst): {
       return eval_context.GetConstantValue(typed_inst.value_id);
     }
+    case CARBON_KIND(SemIR::ParamPattern param_pattern): {
+      return eval_context.GetConstantValue(param_pattern.subpattern_id);
+    }
     case CARBON_KIND(SemIR::Converted typed_inst): {
       return eval_context.GetConstantValue(typed_inst.result_id);
     }
@@ -1466,7 +1491,6 @@ static auto TryEvalInstInContext(EvalContext& eval_context,
     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/generic.cpp

@@ -108,6 +108,12 @@ class RebuildGenericConstantInEvalBlockCallbacks final
       return true;
     }
 
+    if (auto pattern =
+            context_.insts().TryGetAs<SemIR::SymbolicBindingPattern>(inst_id)) {
+      inst_id = Rebuild(inst_id, *pattern);
+      return true;
+    }
+
     return false;
   }
 
@@ -426,39 +432,28 @@ auto ResolveSpecificDefinition(Context& context, SemIR::SpecificId specific_id)
   return true;
 }
 
-// Replace the parameter with an invalid instruction so that we don't try
-// constructing a generic based on it. Note this is updating the param
-// refs block, not the actual params block, so will not be directly
-// reflected in SemIR output.
-static auto ReplaceInstructionWithError(Context& context,
-                                        SemIR::InstId& inst_id) -> void {
-  inst_id = context.AddInstInNoBlock<SemIR::Param>(
-      context.insts().GetLocId(inst_id),
-      {.type_id = SemIR::TypeId::Error,
-       .name_id = SemIR::NameId::Base,
-       .runtime_index = SemIR::RuntimeParamIndex::Invalid});
-}
-
-auto RequireGenericParamsOnType(Context& context, SemIR::InstBlockId block_id)
-    -> void {
-  if (!block_id.is_valid() || block_id == SemIR::InstBlockId::Empty) {
+auto RequireGenericParamsOnType(Context& context,
+                                SemIR::InstBlockId pattern_block_id) -> void {
+  if (!pattern_block_id.is_valid() ||
+      pattern_block_id == SemIR::InstBlockId::Empty) {
     return;
   }
-  for (auto& inst_id : context.inst_blocks().Get(block_id)) {
-    auto param_info =
-        SemIR::Function::GetParamFromParamRefId(context.sem_ir(), inst_id);
-    if (param_info.GetNameId(context.sem_ir()) == SemIR::NameId::SelfValue) {
+  for (auto& inst_id : context.inst_blocks().Get(pattern_block_id)) {
+    auto name_id = SemIR::Function::GetParamPatternInfoFromPatternId(
+                       context.sem_ir(), inst_id)
+                       .GetNameId(context.sem_ir());
+    if (name_id == SemIR::NameId::SelfValue) {
       CARBON_DIAGNOSTIC(SelfParameterNotAllowed, Error,
                         "`self` parameter only allowed on functions");
       context.emitter().Emit(inst_id, SelfParameterNotAllowed);
 
-      ReplaceInstructionWithError(context, inst_id);
+      inst_id = SemIR::InstId::BuiltinError;
     } else if (!context.constant_values().Get(inst_id).is_constant()) {
       CARBON_DIAGNOSTIC(GenericParamMustBeConstant, Error,
                         "parameters of generic types must be constant");
       context.emitter().Emit(inst_id, GenericParamMustBeConstant);
 
-      ReplaceInstructionWithError(context, inst_id);
+      inst_id = SemIR::InstId::BuiltinError;
     }
   }
 }
@@ -479,7 +474,7 @@ auto RequireGenericOrSelfImplicitFunctionParams(Context& context,
           "implicit parameters of functions must be constant or `self`");
       context.emitter().Emit(inst_id, ImplictParamMustBeConstant);
 
-      ReplaceInstructionWithError(context, inst_id);
+      inst_id = SemIR::InstId::BuiltinError;
     }
   }
 }