Finish renaming BindName and related insts. (#6281)

Resolves the TODO from #6235

Author: geoffromer

toolchain/check/context.h

@@ -176,7 +176,7 @@ class Context {
   // TODO: Consider putting this behind a narrower API to guard against emitting
   // multiple times.
   struct BindingPatternInfo {
-    // The corresponding AnyBindName inst.
+    // The corresponding AnyBinding inst.
     SemIR::InstId bind_name_id;
     // The region of insts that computes the type of the binding.
     SemIR::ExprRegionId type_expr_region_id;

toolchain/check/convert.cpp

@@ -1015,7 +1015,7 @@ static auto PerformBuiltinConversion(
             {.type_id = target.type_id, .source_id = value_id});
 
         if (need_value_binding) {
-          value_id = AddInst<SemIR::BindValue>(
+          value_id = AddInst<SemIR::AcquireValue>(
               context, loc_id,
               {.type_id = target.type_id, .value_id = value_id});
         }
@@ -1226,9 +1226,9 @@ static auto PerformBuiltinConversion(
       // converting back to the type of the original symbolic binding facet
       // value.
       //
-      // In the case where the FacetAccessType wraps a BindSymbolicName with the
+      // In the case where the FacetAccessType wraps a SymbolicBinding with the
       // exact facet type that we are converting to, the resulting FacetValue
-      // would evaluate back to the original BindSymbolicName as its canonical
+      // would evaluate back to the original SymbolicBinding as its canonical
       // form. We can skip past the whole impl lookup step then and do that
       // here.
       //
@@ -1576,7 +1576,7 @@ auto Convert(Context& context, SemIR::LocId loc_id, SemIR::InstId expr_id,
 
       // If we have a reference and don't want one, form a value binding.
       // TODO: Support types with custom value representations.
-      expr_id = AddInst<SemIR::BindValue>(
+      expr_id = AddInst<SemIR::AcquireValue>(
           context, SemIR::LocId(expr_id),
           {.type_id = target.type_id, .value_id = expr_id});
       // We now have a value expression.

toolchain/check/deduce.cpp

@@ -375,7 +375,7 @@ auto DeductionContext::Deduce() -> bool {
       // Deducing a symbolic binding appearing within an expression against a
       // constant value deduces the binding as having that value. For example,
       // deducing `[T:! type](x: T)` against `("foo")` deduces `T` as `String`.
-      case CARBON_KIND(SemIR::BindSymbolicName bind): {
+      case CARBON_KIND(SemIR::SymbolicBinding bind): {
         auto& entity_name = context().entity_names().Get(bind.entity_name_id);
         auto index = entity_name.bind_index();
         if (!index.has_value() || index < first_deduced_index_ ||
@@ -465,7 +465,7 @@ static auto GetEntityNameForGenericBinding(Context& context,
   binding_id = context.constant_values().GetConstantInstId(binding_id);
 
   if (auto bind_name =
-          context.insts().TryGetAs<SemIR::AnyBindName>(binding_id)) {
+          context.insts().TryGetAs<SemIR::AnyBinding>(binding_id)) {
     return context.entity_names().Get(bind_name->entity_name_id).name_id;
   } else {
     CARBON_FATAL("Instruction without entity name in generic binding position");

toolchain/check/eval.cpp

@@ -85,7 +85,7 @@ class EvalContext {
 
   // Gets the value of the specified compile-time binding in this context.
   // Returns `None` if the value is not fixed in this context.
-  auto GetCompileTimeBindValue(SemIR::CompileTimeBindIndex bind_index)
+  auto GetCompileTimeAcquireValue(SemIR::CompileTimeBindIndex bind_index)
       -> SemIR::ConstantId {
     if (!bind_index.has_value() || !specific_id_.has_value()) {
       return SemIR::ConstantId::None;
@@ -2142,18 +2142,18 @@ auto TryEvalTypedInst<SemIR::ImportRefLoaded>(EvalContext& /*eval_context*/,
 // Symbolic bindings are a special case because they can reach into the eval
 // context and produce a context-specific value.
 template <>
-auto TryEvalTypedInst<SemIR::BindSymbolicName>(EvalContext& eval_context,
-                                               SemIR::InstId inst_id,
-                                               SemIR::Inst inst)
+auto TryEvalTypedInst<SemIR::SymbolicBinding>(EvalContext& eval_context,
+                                              SemIR::InstId inst_id,
+                                              SemIR::Inst inst)
     -> SemIR::ConstantId {
-  auto bind = inst.As<SemIR::BindSymbolicName>();
+  auto bind = inst.As<SemIR::SymbolicBinding>();
 
   // 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.
   const auto& bind_name = eval_context.entity_names().Get(bind.entity_name_id);
   if (bind_name.bind_index().has_value()) {
     if (auto value =
-            eval_context.GetCompileTimeBindValue(bind_name.bind_index());
+            eval_context.GetCompileTimeAcquireValue(bind_name.bind_index());
         value.has_value()) {
       return value;
     }
@@ -2165,7 +2165,7 @@ auto TryEvalTypedInst<SemIR::BindSymbolicName>(EvalContext& eval_context,
   bind.value_id = SemIR::InstId::None;
   if (!ReplaceTypeWithConstantValue(eval_context, inst_id, &bind, &phase) ||
       !ReplaceFieldWithConstantValue(eval_context, &bind,
-                                     &SemIR::BindSymbolicName::entity_name_id,
+                                     &SemIR::SymbolicBinding::entity_name_id,
                                      &phase)) {
     return SemIR::ConstantId::NotConstant;
   }
@@ -2184,14 +2184,14 @@ auto TryEvalTypedInst<SemIR::SymbolicBindingType>(EvalContext& eval_context,
       inst.As<SemIR::SymbolicBindingType>().entity_name_id);
   if (bind_name.bind_index().has_value()) {
     if (auto value =
-            eval_context.GetCompileTimeBindValue(bind_name.bind_index());
+            eval_context.GetCompileTimeAcquireValue(bind_name.bind_index());
         value.has_value()) {
       auto value_inst_id = eval_context.constant_values().GetInstId(value);
 
       // A SymbolicBindingType can evaluate to a FacetAccessType if the new
       // value of the entity is a facet value that that does not have a concrete
       // type (a FacetType) and does not have a new EntityName to point to (a
-      // BindSymbolicName).
+      // SymbolicBinding).
       auto access = SemIR::FacetAccessType{
           .type_id = SemIR::TypeType::TypeId,
           .facet_value_inst_id = value_inst_id,

toolchain/check/eval_inst.cpp

@@ -98,7 +98,7 @@ auto EvalConstantInst(Context& context, SemIR::AsCompatible inst)
   return ConstantEvalResult::NewAnyPhase(value_inst);
 }
 
-auto EvalConstantInst(Context& context, SemIR::BindAlias inst)
+auto EvalConstantInst(Context& context, SemIR::AliasBinding inst)
     -> ConstantEvalResult {
   // An alias evaluates to the value it's bound to.
   return ConstantEvalResult::Existing(
@@ -121,7 +121,7 @@ auto EvalConstantInst(Context& /*context*/, SemIR::ValueBinding /*inst*/)
   return ConstantEvalResult::NotConstant;
 }
 
-auto EvalConstantInst(Context& /*context*/, SemIR::BindValue /*inst*/)
+auto EvalConstantInst(Context& /*context*/, SemIR::AcquireValue /*inst*/)
     -> ConstantEvalResult {
   // TODO: Handle this once we've decided how to represent constant values of
   // reference expressions.
@@ -204,7 +204,7 @@ auto EvalConstantInst(Context& context, SemIR::FacetAccessType inst)
         context.constant_values().Get(facet_value->type_inst_id));
   }
 
-  if (auto bind_name = context.insts().TryGetAs<SemIR::BindSymbolicName>(
+  if (auto bind_name = context.insts().TryGetAs<SemIR::SymbolicBinding>(
           inst.facet_value_inst_id)) {
     return ConstantEvalResult::NewSamePhase(SemIR::SymbolicBindingType{
         .type_id = SemIR::TypeType::TypeId,
@@ -233,13 +233,13 @@ auto EvalConstantInst(Context& context, SemIR::FacetAccessType inst)
 
 auto EvalConstantInst(Context& context, SemIR::FacetValue inst)
     -> ConstantEvalResult {
-  // A FacetValue that just wraps a BindSymbolicName without adding/removing any
-  // witnesses is evaluated back to the BindSymbolicName itself.
+  // A FacetValue that just wraps a SymbolicBinding without adding/removing any
+  // witnesses is evaluated back to the SymbolicBinding itself.
   if (auto bind_as_type = context.insts().TryGetAs<SemIR::SymbolicBindingType>(
           inst.type_inst_id)) {
     // TODO: Look in ScopeStack with the entity_name_id to find the facet value.
     auto bind_id = bind_as_type->facet_value_inst_id;
-    auto bind = context.insts().GetAs<SemIR::BindSymbolicName>(bind_id);
+    auto bind = context.insts().GetAs<SemIR::SymbolicBinding>(bind_id);
     // If the FacetTypes are the same, then the FacetValue didn't add/remove
     // any witnesses.
     if (bind.type_id == inst.type_id) {

toolchain/check/facet_type.cpp

@@ -636,7 +636,7 @@ auto MakePeriodSelfFacetValue(Context& context, SemIR::TypeId self_type_id)
       .parent_scope_id = context.scope_stack().PeekNameScopeId(),
   });
   auto inst_id = AddInst(
-      context, SemIR::LocIdAndInst::NoLoc<SemIR::BindSymbolicName>({
+      context, SemIR::LocIdAndInst::NoLoc<SemIR::SymbolicBinding>({
                    .type_id = self_type_id,
                    .entity_name_id = entity_name_id,
                    // `None` because there is no equivalent non-symbolic value.

toolchain/check/facet_type.h

@@ -107,7 +107,7 @@ auto ResolveFacetTypeRewriteConstraints(
     -> bool;
 
 // Introduce `.Self` as a symbolic binding into the current scope, and return
-// the `BindSymbolicName` instruction.
+// the `SymbolicBinding` instruction.
 //
 // The `self_type_id` is either a facet type (as `FacetType`) or `type` (as
 // `TypeType`).

toolchain/check/generic.cpp

@@ -149,7 +149,7 @@ class RebuildGenericConstantInEvalBlockCallbacks : public SubstInstCallbacks {
   auto ReuseUnchanged(SemIR::InstId orig_inst_id) -> SemIR::InstId override {
     auto inst = context().insts().Get(orig_inst_id);
     CARBON_CHECK(
-        inst.Is<SemIR::BindSymbolicName>() ||
+        inst.Is<SemIR::SymbolicBinding>() ||
             inst.Is<SemIR::SymbolicBindingPattern>(),
         "Instruction {0} has symbolic constant value but no symbolic operands",
         inst);

toolchain/check/handle_alias.cpp

@@ -66,10 +66,11 @@ auto HandleParseNode(Context& context, Parse::AliasId /*node_id*/) -> bool {
     alias_type_id = SemIR::ErrorInst::TypeId;
     alias_value_id = SemIR::ErrorInst::InstId;
   }
-  auto alias_id = AddInst<SemIR::BindAlias>(context, name_context.loc_id,
-                                            {.type_id = alias_type_id,
-                                             .entity_name_id = entity_name_id,
-                                             .value_id = alias_value_id});
+  auto alias_id =
+      AddInst<SemIR::AliasBinding>(context, name_context.loc_id,
+                                   {.type_id = alias_type_id,
+                                    .entity_name_id = entity_name_id,
+                                    .value_id = alias_value_id});
 
   // Add the name of the binding to the current scope.
   context.decl_name_stack().PopScope();

toolchain/check/handle_binding_pattern.cpp

@@ -74,11 +74,11 @@ static auto HandleAnyBindingPattern(Context& context, Parse::NodeId node_id,
         AddBindingPattern(context, name_node, name_id, cast_type_id,
                           type_expr_region_id, pattern_inst_kind, is_template);
 
-    // TODO: If `is_generic`, then `binding.bind_id is a BindSymbolicName. Subst
+    // TODO: If `is_generic`, then `binding.bind_id is a SymbolicBinding. 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.
+    // will also reuse the CompileTimeBinding for the new SymbolicBinding.
 
     if (name_id != SemIR::NameId::Underscore) {
       // Add name to lookup immediately, so it can be used in the rest of the