Add a `Field` node for fields in a class. (#3332)

This replaces the use of `VarStorage` in this case.

Add an `UnboundFieldType` type as the type of a field, in cases where
it's referenced without an accompanying object.

Add a `BindName` node to describe the name binding performed for both
variables and fields so that we can handle them more uniformly.

toolchain/check/context.cpp

@@ -136,8 +136,10 @@ auto Context::LookupName(Parse::Node parse_node, StringId name_id,
   }
 }
 
-auto Context::PushScope(SemIR::NameScopeId scope_id) -> void {
-  scope_stack_.push_back({.scope_id = scope_id});
+auto Context::PushScope(SemIR::NodeId scope_node_id,
+                        SemIR::NameScopeId scope_id) -> void {
+  scope_stack_.push_back(
+      {.scope_node_id = scope_node_id, .scope_id = scope_id});
 }
 
 auto Context::PopScope() -> void {
@@ -607,6 +609,7 @@ class TypeCompleter {
       case SemIR::Call::Kind:
       case SemIR::ClassDeclaration::Kind:
       case SemIR::Dereference::Kind:
+      case SemIR::Field::Kind:
       case SemIR::FunctionDeclaration::Kind:
       case SemIR::InitializeFrom::Kind:
       case SemIR::IntegerLiteral::Kind:
@@ -663,6 +666,7 @@ class TypeCompleter {
         CARBON_FATAL() << "Builtins should be named as cross-references";
 
       case SemIR::PointerType::Kind:
+      case SemIR::UnboundFieldType::Kind:
         return MakeCopyRepresentation(type_id);
 
       case SemIR::ConstType::Kind:
@@ -791,6 +795,12 @@ static auto ProfileType(Context& semantics_context, SemIR::Node node,
                            node.As<SemIR::TupleType>().elements_id),
                        canonical_id);
       break;
+    case SemIR::UnboundFieldType::Kind: {
+      auto unbound_field_type = node.As<SemIR::UnboundFieldType>();
+      canonical_id.AddInteger(unbound_field_type.class_type_id.index);
+      canonical_id.AddInteger(unbound_field_type.field_type_id.index);
+      break;
+    }
     default:
       CARBON_FATAL() << "Unexpected type node " << node;
   }

toolchain/check/context.h

@@ -70,14 +70,27 @@ class Context {
       -> void;
 
   // Pushes a new scope onto scope_stack_.
-  auto PushScope(SemIR::NameScopeId scope_id = SemIR::NameScopeId::Invalid)
+  auto PushScope(SemIR::NodeId scope_node_id = SemIR::NodeId::Invalid,
+                 SemIR::NameScopeId scope_id = SemIR::NameScopeId::Invalid)
       -> void;
 
   // Pops the top scope from scope_stack_, cleaning up names from name_lookup_.
   auto PopScope() -> void;
 
+  // Returns the name scope associated with the current lexical scope, if any.
   auto current_scope_id() const -> SemIR::NameScopeId {
-    return scope_stack_.back().scope_id;
+    return current_scope().scope_id;
+  }
+
+  // Returns the current scope, if it is of the specified kind. Otherwise,
+  // returns nullopt.
+  template <typename NodeT>
+  auto GetCurrentScopeAs() -> std::optional<NodeT> {
+    auto current_scope_node_id = current_scope().scope_node_id;
+    if (!current_scope_node_id.is_valid()) {
+      return std::nullopt;
+    }
+    return nodes().Get(current_scope_node_id).TryAs<NodeT>();
   }
 
   // Follows NameReference nodes to find the value named by a given node.
@@ -265,6 +278,14 @@ class Context {
 
   // An entry in scope_stack_.
   struct ScopeStackEntry {
+    // The node associated with this entry, if any. This can be one of:
+    //
+    // - A `ClassDeclaration`, for a class definition scope.
+    // - A `FunctionDeclaration`, for the outermost scope in a function
+    //   definition.
+    // - Invalid, for any other scope.
+    SemIR::NodeId scope_node_id;
+
     // The name scope associated with this entry, if any.
     SemIR::NameScopeId scope_id;
 
@@ -297,6 +318,9 @@ class Context {
   auto CanonicalizeTypeAndAddNodeIfNew(SemIR::Node node) -> SemIR::TypeId;
 
   auto current_scope() -> ScopeStackEntry& { return scope_stack_.back(); }
+  auto current_scope() const -> const ScopeStackEntry& {
+    return scope_stack_.back();
+  }
 
   // Tokens for getting data on literals.
   const Lex::TokenizedBuffer* tokens_;

toolchain/check/handle_class.cpp

@@ -103,8 +103,9 @@ auto HandleClassDefinitionStart(Context& context, Parse::Node parse_node)
   }
 
   // Enter the class scope.
-  context.PushScope(class_info.scope_id);
+  context.PushScope(class_decl_id, class_info.scope_id);
   context.node_block_stack().Push();
+  context.node_stack().Push(parse_node, class_id);
 
   // TODO: Handle the case where there's control flow in the class body. For
   // example:
@@ -120,6 +121,7 @@ auto HandleClassDefinitionStart(Context& context, Parse::Node parse_node)
 
 auto HandleClassDefinition(Context& context, Parse::Node /*parse_node*/)
     -> bool {
+  context.node_stack().Pop<Parse::NodeKind::ClassDefinitionStart>();
   context.node_block_stack().Pop();
   context.PopScope();
 

toolchain/check/handle_file.cpp

@@ -0,0 +1,21 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "toolchain/check/context.h"
+
+namespace Carbon::Check {
+
+auto HandleFileStart(Context& /*context*/, Parse::Node /*parse_node*/) -> bool {
+  // No action to perform.
+  // TODO: We may want to push `FileStart` as a sentinel so that `Peek`s can't
+  // fail.
+  return true;
+}
+
+auto HandleFileEnd(Context& /*context*/, Parse::Node /*parse_node*/) -> bool {
+  // No action to perform.
+  return true;
+}
+
+}  // namespace Carbon::Check

toolchain/check/handle_function.cpp

@@ -178,7 +178,7 @@ auto HandleFunctionDefinitionStart(Context& context, Parse::Node parse_node)
   // Create the function scope and the entry block.
   context.return_scope_stack().push_back(decl_id);
   context.node_block_stack().Push();
-  context.PushScope();
+  context.PushScope(decl_id);
   context.AddCurrentCodeBlockToFunction();
 
   // Bring the parameters into scope.

toolchain/check/handle_noop.cpp

@@ -12,16 +12,6 @@ auto HandleEmptyDeclaration(Context& /*context*/, Parse::Node /*parse_node*/)
   return true;
 }
 
-auto HandleFileStart(Context& /*context*/, Parse::Node /*parse_node*/) -> bool {
-  // Do nothing, no need to balance this node.
-  return true;
-}
-
-auto HandleFileEnd(Context& /*context*/, Parse::Node /*parse_node*/) -> bool {
-  // Do nothing, no need to balance this node.
-  return true;
-}
-
 auto HandleInvalidParse(Context& context, Parse::Node parse_node) -> bool {
   return context.TODO(parse_node, "HandleInvalidParse");
 }

toolchain/check/handle_pattern_binding.cpp

@@ -29,29 +29,50 @@ auto HandlePatternBinding(Context& context, Parse::Node parse_node) -> bool {
 
   // Allocate a node of the appropriate kind, linked to the name for error
   // locations.
-  // TODO: Each of these cases should create a `BindName` node.
   switch (auto context_parse_node_kind = context.parse_tree().node_kind(
               context.node_stack().PeekParseNode())) {
-    case Parse::NodeKind::VariableIntroducer:
+    case Parse::NodeKind::VariableIntroducer: {
+      // A `var` declaration at class scope introduces a field.
+      auto enclosing_class_decl =
+          context.GetCurrentScopeAs<SemIR::ClassDeclaration>();
       if (!context.TryToCompleteType(cast_type_id, [&] {
             CARBON_DIAGNOSTIC(IncompleteTypeInVarDeclaration, Error,
-                              "Variable has incomplete type `{0}`.",
+                              "{0} has incomplete type `{1}`.", llvm::StringRef,
                               std::string);
             return context.emitter().Build(
                 type_node_copy, IncompleteTypeInVarDeclaration,
+                enclosing_class_decl ? "Field" : "Variable",
                 context.sem_ir().StringifyType(cast_type_id, true));
           })) {
         cast_type_id = SemIR::TypeId::Error;
       }
+      SemIR::NodeId value_id = SemIR::NodeId::Invalid;
+      SemIR::TypeId value_type_id = cast_type_id;
+      if (enclosing_class_decl) {
+        auto& class_info =
+            context.classes().Get(enclosing_class_decl->class_id);
+        auto field_type_node_id = context.AddNode(SemIR::UnboundFieldType{
+            parse_node, context.GetBuiltinType(SemIR::BuiltinKind::TypeType),
+            class_info.self_type_id, cast_type_id});
+        value_type_id = context.CanonicalizeType(field_type_node_id);
+        value_id =
+            context.AddNode(SemIR::Field{parse_node, value_type_id, name_id});
+      } else {
+        value_id = context.AddNode(
+            SemIR::VarStorage{name_node, value_type_id, name_id});
+      }
       context.AddNodeAndPush(
-          parse_node, SemIR::VarStorage{name_node, cast_type_id, name_id});
+          parse_node,
+          SemIR::BindName{name_node, value_type_id, name_id, value_id});
       break;
+    }
 
     case Parse::NodeKind::ParameterListStart:
       // Parameters can have incomplete types in a function declaration, but not
       // in a function definition. We don't know which kind we have here.
       context.AddNodeAndPush(
           parse_node, SemIR::Parameter{name_node, cast_type_id, name_id});
+      // TODO: Create a `BindName` node.
       break;
 
     case Parse::NodeKind::LetIntroducer:

toolchain/check/handle_variable.cpp

@@ -22,26 +22,30 @@ auto HandleVariableDeclaration(Context& context, Parse::Node parse_node)
   }
 
   // Extract the name binding.
-  SemIR::NodeId var_id =
+  SemIR::NodeId bind_name_id =
       context.node_stack().Pop<Parse::NodeKind::PatternBinding>();
-  auto var = context.nodes().GetAs<SemIR::VarStorage>(var_id);
+  auto bind_name = context.nodes().GetAs<SemIR::BindName>(bind_name_id);
 
   // Form a corresponding name in the current context, and bind the name to the
   // variable.
   context.declaration_name_stack().AddNameToLookup(
-      context.declaration_name_stack().MakeUnqualifiedName(var.parse_node,
-                                                           var.name_id),
-      var_id);
+      context.declaration_name_stack().MakeUnqualifiedName(bind_name.parse_node,
+                                                           bind_name.name_id),
+      bind_name_id);
 
   // If there was an initializer, assign it to the storage.
-  //
-  // TODO: In a class scope, we should instead save the initializer somewhere
-  // so that we can use it as a default.
   if (has_init) {
-    init_id = Initialize(context, parse_node, var_id, init_id);
-    // TODO: Consider using different node kinds for assignment versus
-    // initialization.
-    context.AddNode(SemIR::Assign{parse_node, var_id, init_id});
+    auto var_id = bind_name.value_id;
+    if (context.nodes().Get(var_id).Is<SemIR::VarStorage>()) {
+      init_id = Initialize(context, parse_node, var_id, init_id);
+      // TODO: Consider using different node kinds for assignment versus
+      // initialization.
+      context.AddNode(SemIR::Assign{parse_node, var_id, init_id});
+    } else {
+      // TODO: In a class scope, we should instead save the initializer
+      // somewhere so that we can use it as a default.
+      context.TODO(parse_node, "Field initializer");
+    }
   }
 
   context.node_stack()

toolchain/check/node_stack.h

@@ -140,10 +140,12 @@ class NodeStack {
     return PopWithParseNode<RequiredParseKind>().second;
   }
 
-  // Peeks at the parse_node of the top of the stack.
+  // Peeks at the parse_node of the given depth in the stack, or by default the
+  // top node.
   auto PeekParseNode() -> Parse::Node { return stack_.back().parse_node; }
 
-  // Peeks at the ID of the top of the stack.
+  // Peeks at the ID of node at the given depth in the stack, or by default the
+  // top node.
   template <Parse::NodeKind::RawEnumType RequiredParseKind>
   auto Peek() -> auto {
     Entry back = stack_.back();
@@ -202,6 +204,8 @@ class NodeStack {
         : parse_node(parse_node), node_block_id(node_block_id) {}
     explicit Entry(Parse::Node parse_node, SemIR::FunctionId function_id)
         : parse_node(parse_node), function_id(function_id) {}
+    explicit Entry(Parse::Node parse_node, SemIR::ClassId class_id)
+        : parse_node(parse_node), class_id(class_id) {}
     explicit Entry(Parse::Node parse_node, StringId name_id)
         : parse_node(parse_node), name_id(name_id) {}
     explicit Entry(Parse::Node parse_node, SemIR::TypeId type_id)
@@ -219,6 +223,9 @@ class NodeStack {
       if constexpr (std::is_same<T, SemIR::FunctionId>()) {
         return function_id;
       }
+      if constexpr (std::is_same<T, SemIR::ClassId>()) {
+        return class_id;
+      }
       if constexpr (std::is_same<T, StringId>()) {
         return name_id;
       }
@@ -239,6 +246,7 @@ class NodeStack {
       SemIR::NodeId node_id;
       SemIR::NodeBlockId node_block_id;
       SemIR::FunctionId function_id;
+      SemIR::ClassId class_id;
       StringId name_id;
       SemIR::TypeId type_id;
     };
@@ -278,6 +286,8 @@ class NodeStack {
         return IdKind::NodeBlockId;
       case Parse::NodeKind::FunctionDefinitionStart:
         return IdKind::FunctionId;
+      case Parse::NodeKind::ClassDefinitionStart:
+        return IdKind::ClassId;
       case Parse::NodeKind::Name:
         return IdKind::StringId;
       case Parse::NodeKind::ArrayExpressionSemi:

toolchain/check/testdata/array/array_in_place.carbon

@@ -24,22 +24,23 @@ fn G() {
 // CHECK:STDOUT:   %.loc10_28: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_29.1: type = array_type %.loc10_28, (i32, i32, i32)
 // CHECK:STDOUT:   %.loc10_29.2: type = ptr_type [(i32, i32, i32); 2]
-// CHECK:STDOUT:   %v: ref [(i32, i32, i32); 2] = var "v"
+// CHECK:STDOUT:   %v.var: ref [(i32, i32, i32); 2] = var "v"
+// CHECK:STDOUT:   %v: ref [(i32, i32, i32); 2] = bind_name "v", %v.var
 // CHECK:STDOUT:   %F.ref.loc10_34: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc10_42.3: ref (i32, i32, i32) = splice_block %.loc10_42.2 {
 // CHECK:STDOUT:     %.loc10_42.1: i32 = int_literal 0
-// CHECK:STDOUT:     %.loc10_42.2: ref (i32, i32, i32) = array_index %v, %.loc10_42.1
+// CHECK:STDOUT:     %.loc10_42.2: ref (i32, i32, i32) = array_index %v.var, %.loc10_42.1
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %.loc10_35: init (i32, i32, i32) = call %F.ref.loc10_34() to %.loc10_42.3
 // CHECK:STDOUT:   %F.ref.loc10_39: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc10_42.6: ref (i32, i32, i32) = splice_block %.loc10_42.5 {
 // CHECK:STDOUT:     %.loc10_42.4: i32 = int_literal 1
-// CHECK:STDOUT:     %.loc10_42.5: ref (i32, i32, i32) = array_index %v, %.loc10_42.4
+// CHECK:STDOUT:     %.loc10_42.5: ref (i32, i32, i32) = array_index %v.var, %.loc10_42.4
 // CHECK:STDOUT:   }
 // CHECK:STDOUT:   %.loc10_40: init (i32, i32, i32) = call %F.ref.loc10_39() to %.loc10_42.6
 // CHECK:STDOUT:   %.loc10_42.7: type = tuple_type ((i32, i32, i32), (i32, i32, i32))
 // CHECK:STDOUT:   %.loc10_42.8: ((i32, i32, i32), (i32, i32, i32)) = tuple_literal (%.loc10_35, %.loc10_40)
-// CHECK:STDOUT:   %.loc10_42.9: init [(i32, i32, i32); 2] = array_init %.loc10_42.8, (%.loc10_35, %.loc10_40) to %v
-// CHECK:STDOUT:   assign %v, %.loc10_42.9
+// CHECK:STDOUT:   %.loc10_42.9: init [(i32, i32, i32); 2] = array_init %.loc10_42.8, (%.loc10_35, %.loc10_40) to %v.var
+// CHECK:STDOUT:   assign %v.var, %.loc10_42.9
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/array/assign_return_value.carbon

@@ -28,7 +28,8 @@ fn Run() {
 // CHECK:STDOUT:   %.loc10_16: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_17.1: type = array_type %.loc10_16, i32
 // CHECK:STDOUT:   %.loc10_17.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %t: ref [i32; 1] = var "t"
+// CHECK:STDOUT:   %t.var: ref [i32; 1] = var "t"
+// CHECK:STDOUT:   %t: ref [i32; 1] = bind_name "t", %t.var
 // CHECK:STDOUT:   %F.ref: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc10_22.1: init (i32,) = call %F.ref()
 // CHECK:STDOUT:   %.loc10_22.2: ref (i32,) = temporary_storage
@@ -36,9 +37,9 @@ fn Run() {
 // CHECK:STDOUT:   %.loc10_22.4: ref i32 = tuple_access %.loc10_22.3, member0
 // CHECK:STDOUT:   %.loc10_22.5: i32 = bind_value %.loc10_22.4
 // CHECK:STDOUT:   %.loc10_22.6: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc10_22.7: ref i32 = array_index %t, %.loc10_22.6
+// CHECK:STDOUT:   %.loc10_22.7: ref i32 = array_index %t.var, %.loc10_22.6
 // CHECK:STDOUT:   %.loc10_22.8: init i32 = initialize_from %.loc10_22.5 to %.loc10_22.7
-// CHECK:STDOUT:   %.loc10_22.9: init [i32; 1] = array_init %.loc10_22.3, (%.loc10_22.8) to %t
-// CHECK:STDOUT:   assign %t, %.loc10_22.9
+// CHECK:STDOUT:   %.loc10_22.9: init [i32; 1] = array_init %.loc10_22.3, (%.loc10_22.8) to %t.var
+// CHECK:STDOUT:   assign %t.var, %.loc10_22.9
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/array/assign_var.carbon

@@ -12,39 +12,41 @@ var b: [i32; 3] = a;
 // CHECK:STDOUT:   %.loc7_22.2: (type, type, type) = tuple_literal (i32, i32, i32)
 // CHECK:STDOUT:   %.loc7_22.3: type = tuple_type (i32, i32, i32)
 // CHECK:STDOUT:   %.loc7_22.4: type = ptr_type (i32, i32, i32)
-// CHECK:STDOUT:   %a: ref (i32, i32, i32) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32, i32, i32) = var "a"
+// CHECK:STDOUT:   %a: ref (i32, i32, i32) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_27: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_30: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_33: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc7_34.1: (i32, i32, i32) = tuple_literal (%.loc7_27, %.loc7_30, %.loc7_33)
-// CHECK:STDOUT:   %.loc7_34.2: ref i32 = tuple_access %a, member0
+// CHECK:STDOUT:   %.loc7_34.2: ref i32 = tuple_access %a.var, member0
 // CHECK:STDOUT:   %.loc7_34.3: init i32 = initialize_from %.loc7_27 to %.loc7_34.2
-// CHECK:STDOUT:   %.loc7_34.4: ref i32 = tuple_access %a, member1
+// CHECK:STDOUT:   %.loc7_34.4: ref i32 = tuple_access %a.var, member1
 // CHECK:STDOUT:   %.loc7_34.5: init i32 = initialize_from %.loc7_30 to %.loc7_34.4
-// CHECK:STDOUT:   %.loc7_34.6: ref i32 = tuple_access %a, member2
+// CHECK:STDOUT:   %.loc7_34.6: ref i32 = tuple_access %a.var, member2
 // CHECK:STDOUT:   %.loc7_34.7: init i32 = initialize_from %.loc7_33 to %.loc7_34.6
 // CHECK:STDOUT:   %.loc7_34.8: init (i32, i32, i32) = tuple_init %.loc7_34.1, (%.loc7_34.3, %.loc7_34.5, %.loc7_34.7)
-// CHECK:STDOUT:   assign %a, %.loc7_34.8
+// CHECK:STDOUT:   assign %a.var, %.loc7_34.8
 // CHECK:STDOUT:   %.loc8_14: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc8_15.1: type = array_type %.loc8_14, i32
 // CHECK:STDOUT:   %.loc8_15.2: type = ptr_type [i32; 3]
-// CHECK:STDOUT:   %b: ref [i32; 3] = var "b"
+// CHECK:STDOUT:   %b.var: ref [i32; 3] = var "b"
+// CHECK:STDOUT:   %b: ref [i32; 3] = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32, i32, i32) = name_reference "a", %a
 // CHECK:STDOUT:   %.loc8_19.1: ref i32 = tuple_access %a.ref, member0
 // CHECK:STDOUT:   %.loc8_19.2: i32 = bind_value %.loc8_19.1
 // CHECK:STDOUT:   %.loc8_19.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc8_19.4: ref i32 = array_index %b, %.loc8_19.3
+// CHECK:STDOUT:   %.loc8_19.4: ref i32 = array_index %b.var, %.loc8_19.3
 // CHECK:STDOUT:   %.loc8_19.5: init i32 = initialize_from %.loc8_19.2 to %.loc8_19.4
 // CHECK:STDOUT:   %.loc8_19.6: ref i32 = tuple_access %a.ref, member1
 // CHECK:STDOUT:   %.loc8_19.7: i32 = bind_value %.loc8_19.6
 // CHECK:STDOUT:   %.loc8_19.8: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc8_19.9: ref i32 = array_index %b, %.loc8_19.8
+// CHECK:STDOUT:   %.loc8_19.9: ref i32 = array_index %b.var, %.loc8_19.8
 // CHECK:STDOUT:   %.loc8_19.10: init i32 = initialize_from %.loc8_19.7 to %.loc8_19.9
 // CHECK:STDOUT:   %.loc8_19.11: ref i32 = tuple_access %a.ref, member2
 // CHECK:STDOUT:   %.loc8_19.12: i32 = bind_value %.loc8_19.11
 // CHECK:STDOUT:   %.loc8_19.13: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc8_19.14: ref i32 = array_index %b, %.loc8_19.13
+// CHECK:STDOUT:   %.loc8_19.14: ref i32 = array_index %b.var, %.loc8_19.13
 // CHECK:STDOUT:   %.loc8_19.15: init i32 = initialize_from %.loc8_19.12 to %.loc8_19.14
-// CHECK:STDOUT:   %.loc8_19.16: init [i32; 3] = array_init %a.ref, (%.loc8_19.5, %.loc8_19.10, %.loc8_19.15) to %b
-// CHECK:STDOUT:   assign %b, %.loc8_19.16
+// CHECK:STDOUT:   %.loc8_19.16: init [i32; 3] = array_init %a.ref, (%.loc8_19.5, %.loc8_19.10, %.loc8_19.15) to %b.var
+// CHECK:STDOUT:   assign %b.var, %.loc8_19.16
 // CHECK:STDOUT: }

toolchain/check/testdata/array/base.carbon

@@ -12,37 +12,40 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %a: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 1] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_22.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc7_22.2: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_22.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_22.4: ref i32 = array_index %a, %.loc7_22.3
+// CHECK:STDOUT:   %.loc7_22.4: ref i32 = array_index %a.var, %.loc7_22.3
 // CHECK:STDOUT:   %.loc7_22.5: init i32 = initialize_from %.loc7_20 to %.loc7_22.4
-// CHECK:STDOUT:   %.loc7_22.6: init [i32; 1] = array_init %.loc7_22.2, (%.loc7_22.5) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_22.6
+// CHECK:STDOUT:   %.loc7_22.6: init [i32; 1] = array_init %.loc7_22.2, (%.loc7_22.5) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_22.6
 // CHECK:STDOUT:   %.loc8_14: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc8_15.1: type = array_type %.loc8_14, f64
 // CHECK:STDOUT:   %.loc8_15.2: type = ptr_type [f64; 2]
-// CHECK:STDOUT:   %b: ref [f64; 2] = var "b"
+// CHECK:STDOUT:   %b.var: ref [f64; 2] = var "b"
+// CHECK:STDOUT:   %b: ref [f64; 2] = bind_name "b", %b.var
 // CHECK:STDOUT:   %.loc8_20: f64 = real_literal 111e-1
 // CHECK:STDOUT:   %.loc8_26: f64 = real_literal 22e-1
 // CHECK:STDOUT:   %.loc8_30.1: type = tuple_type (f64, f64)
 // CHECK:STDOUT:   %.loc8_30.2: (f64, f64) = tuple_literal (%.loc8_20, %.loc8_26)
 // CHECK:STDOUT:   %.loc8_30.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc8_30.4: ref f64 = array_index %b, %.loc8_30.3
+// CHECK:STDOUT:   %.loc8_30.4: ref f64 = array_index %b.var, %.loc8_30.3
 // CHECK:STDOUT:   %.loc8_30.5: init f64 = initialize_from %.loc8_20 to %.loc8_30.4
 // CHECK:STDOUT:   %.loc8_30.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc8_30.7: ref f64 = array_index %b, %.loc8_30.6
+// CHECK:STDOUT:   %.loc8_30.7: ref f64 = array_index %b.var, %.loc8_30.6
 // CHECK:STDOUT:   %.loc8_30.8: init f64 = initialize_from %.loc8_26 to %.loc8_30.7
-// CHECK:STDOUT:   %.loc8_30.9: init [f64; 2] = array_init %.loc8_30.2, (%.loc8_30.5, %.loc8_30.8) to %b
-// CHECK:STDOUT:   assign %b, %.loc8_30.9
+// CHECK:STDOUT:   %.loc8_30.9: init [f64; 2] = array_init %.loc8_30.2, (%.loc8_30.5, %.loc8_30.8) to %b.var
+// CHECK:STDOUT:   assign %b.var, %.loc8_30.9
 // CHECK:STDOUT:   %.loc9_10.1: type = tuple_type ()
 // CHECK:STDOUT:   %.loc9_10.2: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_13: i32 = int_literal 5
 // CHECK:STDOUT:   %.loc9_14.1: type = array_type %.loc9_13, ()
 // CHECK:STDOUT:   %.loc9_14.2: type = ptr_type [(); 5]
-// CHECK:STDOUT:   %c: ref [(); 5] = var "c"
+// CHECK:STDOUT:   %c.var: ref [(); 5] = var "c"
+// CHECK:STDOUT:   %c: ref [(); 5] = bind_name "c", %c.var
 // CHECK:STDOUT:   %.loc9_20.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_24.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc9_28.1: () = tuple_literal ()
@@ -55,6 +58,6 @@ var c: [(); 5] = ((), (), (), (), (),);
 // CHECK:STDOUT:   %.loc9_28.2: init () = tuple_init %.loc9_28.1, ()
 // CHECK:STDOUT:   %.loc9_32.2: init () = tuple_init %.loc9_32.1, ()
 // CHECK:STDOUT:   %.loc9_36.2: init () = tuple_init %.loc9_36.1, ()
-// CHECK:STDOUT:   %.loc9_38.3: init [(); 5] = array_init %.loc9_38.2, (%.loc9_20.2, %.loc9_24.2, %.loc9_28.2, %.loc9_32.2, %.loc9_36.2) to %c
-// CHECK:STDOUT:   assign %c, %.loc9_38.3
+// CHECK:STDOUT:   %.loc9_38.3: init [(); 5] = array_init %.loc9_38.2, (%.loc9_20.2, %.loc9_24.2, %.loc9_28.2, %.loc9_32.2, %.loc9_36.2) to %c.var
+// CHECK:STDOUT:   assign %c.var, %.loc9_38.3
 // CHECK:STDOUT: }

toolchain/check/testdata/array/fail_bound_overflow.carbon

@@ -12,5 +12,6 @@ var a: [1; 39999999999999999993];
 // CHECK:STDOUT: file "fail_bound_overflow.carbon" {
 // CHECK:STDOUT:   %.loc10_9: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_12: i32 = int_literal 39999999999999999993
-// CHECK:STDOUT:   %a: ref <error> = var "a"
+// CHECK:STDOUT:   %a.var: ref <error> = var "a"
+// CHECK:STDOUT:   %a: ref <error> = bind_name "a", %a.var
 // CHECK:STDOUT: }

toolchain/check/testdata/array/fail_incomplete_element.carbon

@@ -25,15 +25,17 @@ var p: Incomplete* = &a[0];
 // CHECK:STDOUT:   %Incomplete.ref.loc15: type = name_reference "Incomplete", %Incomplete
 // CHECK:STDOUT:   %.loc15_21: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc15_22: type = array_type %.loc15_21, Incomplete
-// CHECK:STDOUT:   %a: ref <error> = var "a"
+// CHECK:STDOUT:   %a.var: ref <error> = var "a"
+// CHECK:STDOUT:   %a: ref <error> = bind_name "a", %a.var
 // CHECK:STDOUT:   %Incomplete.ref.loc20: type = name_reference "Incomplete", %Incomplete
 // CHECK:STDOUT:   %.loc20_18: type = ptr_type Incomplete
-// CHECK:STDOUT:   %p: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p.var: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p: ref Incomplete* = bind_name "p", %p.var
 // CHECK:STDOUT:   %a.ref: ref <error> = name_reference "a", %a
 // CHECK:STDOUT:   %.loc20_25: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc20_22.1: type = ptr_type <error>
 // CHECK:STDOUT:   %.loc20_22.2: <error>* = address_of <error>
-// CHECK:STDOUT:   assign %p, <error>
+// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;

toolchain/check/testdata/array/fail_invalid_type.carbon

@@ -14,5 +14,6 @@ var a: [1; 1];
 // CHECK:STDOUT:   %.loc10_12: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_13.1: type = array_type %.loc10_12, <error>
 // CHECK:STDOUT:   %.loc10_13.2: type = ptr_type [<error>; 1]
-// CHECK:STDOUT:   %a: ref [<error>; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [<error>; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [<error>; 1] = bind_name "a", %a.var
 // CHECK:STDOUT: }

toolchain/check/testdata/array/fail_out_of_bound.carbon

@@ -13,11 +13,12 @@ var a: [i32; 1] = (1, 2, 3);
 // CHECK:STDOUT:   %.loc10_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_15.1: type = array_type %.loc10_14, i32
 // CHECK:STDOUT:   %.loc10_15.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %a: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 1] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc10_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_23: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_26: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc10_27.1: type = tuple_type (i32, i32, i32)
 // CHECK:STDOUT:   %.loc10_27.2: (i32, i32, i32) = tuple_literal (%.loc10_20, %.loc10_23, %.loc10_26)
-// CHECK:STDOUT:   assign %a, <error>
+// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/array/fail_type_mismatch.carbon

@@ -30,7 +30,8 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc10_14: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc10_15.1: type = array_type %.loc10_14, i32
 // CHECK:STDOUT:   %.loc10_15.2: type = ptr_type [i32; 3]
-// CHECK:STDOUT:   %a: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 3] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc10_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.1: type = ptr_type String
 // CHECK:STDOUT:   %.loc10_23: String = string_literal "Hello"
@@ -38,40 +39,45 @@ var d: [i32; 3] = t2;
 // CHECK:STDOUT:   %.loc10_39.1: type = tuple_type (i32, String, String)
 // CHECK:STDOUT:   %.loc10_39.2: (i32, String, String) = tuple_literal (%.loc10_20, %.loc10_23, %.loc10_32)
 // CHECK:STDOUT:   %.loc10_39.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc10_39.4: ref i32 = array_index %a, %.loc10_39.3
+// CHECK:STDOUT:   %.loc10_39.4: ref i32 = array_index %a.var, %.loc10_39.3
 // CHECK:STDOUT:   %.loc10_39.5: init i32 = initialize_from %.loc10_20 to %.loc10_39.4
-// CHECK:STDOUT:   assign %a, <error>
+// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %.loc12_29.1: type = tuple_type (type, type, type)
 // CHECK:STDOUT:   %.loc12_29.2: (type, type, type) = tuple_literal (i32, String, String)
 // CHECK:STDOUT:   %.loc10_39.6: type = tuple_type (i32, String*, String*)
 // CHECK:STDOUT:   %.loc10_39.7: type = ptr_type (i32, String*, String*)
-// CHECK:STDOUT:   %t1: ref (i32, String, String) = var "t1"
+// CHECK:STDOUT:   %t1.var: ref (i32, String, String) = var "t1"
+// CHECK:STDOUT:   %t1: ref (i32, String, String) = bind_name "t1", %t1.var
 // CHECK:STDOUT:   %.loc16_14: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc16_15: type = array_type %.loc16_14, i32
-// CHECK:STDOUT:   %b: ref [i32; 3] = var "b"
+// CHECK:STDOUT:   %b.var: ref [i32; 3] = var "b"
+// CHECK:STDOUT:   %b: ref [i32; 3] = bind_name "b", %b.var
 // CHECK:STDOUT:   %t1.ref: ref (i32, String, String) = name_reference "t1", %t1
 // CHECK:STDOUT:   %.loc16_19.1: ref i32 = tuple_access %t1.ref, member0
 // CHECK:STDOUT:   %.loc16_19.2: i32 = bind_value %.loc16_19.1
 // CHECK:STDOUT:   %.loc16_19.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc16_19.4: ref i32 = array_index %b, %.loc16_19.3
+// CHECK:STDOUT:   %.loc16_19.4: ref i32 = array_index %b.var, %.loc16_19.3
 // CHECK:STDOUT:   %.loc16_19.5: init i32 = initialize_from %.loc16_19.2 to %.loc16_19.4
 // CHECK:STDOUT:   %.loc16_19.6: ref String = tuple_access %t1.ref, member1
-// CHECK:STDOUT:   assign %b, <error>
+// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   %.loc21_14: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc21_15: type = array_type %.loc21_14, i32
-// CHECK:STDOUT:   %c: ref [i32; 3] = var "c"
+// CHECK:STDOUT:   %c.var: ref [i32; 3] = var "c"
+// CHECK:STDOUT:   %c: ref [i32; 3] = bind_name "c", %c.var
 // CHECK:STDOUT:   %.loc21_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc21_23: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc21_24.1: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc21_24.2: (i32, i32) = tuple_literal (%.loc21_20, %.loc21_23)
-// CHECK:STDOUT:   assign %c, <error>
+// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT:   %.loc23_18.1: type = tuple_type (type, type)
 // CHECK:STDOUT:   %.loc23_18.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc21_24.3: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %t2: ref (i32, i32) = var "t2"
+// CHECK:STDOUT:   %t2.var: ref (i32, i32) = var "t2"
+// CHECK:STDOUT:   %t2: ref (i32, i32) = bind_name "t2", %t2.var
 // CHECK:STDOUT:   %.loc27_14: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc27_15: type = array_type %.loc27_14, i32
-// CHECK:STDOUT:   %d: ref [i32; 3] = var "d"
+// CHECK:STDOUT:   %d.var: ref [i32; 3] = var "d"
+// CHECK:STDOUT:   %d: ref [i32; 3] = bind_name "d", %d.var
 // CHECK:STDOUT:   %t2.ref: ref (i32, i32) = name_reference "t2", %t2
-// CHECK:STDOUT:   assign %d, <error>
+// CHECK:STDOUT:   assign %d.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/array/nine_elements.carbon

@@ -10,7 +10,8 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 9
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 9]
-// CHECK:STDOUT:   %a: ref [i32; 9] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 9] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 9] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_23: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 3
@@ -23,32 +24,32 @@ var a: [i32; 9] = (1, 2, 3, 4, 5, 6, 7, 8, 9);
 // CHECK:STDOUT:   %.loc7_45.1: type = tuple_type (i32, i32, i32, i32, i32, i32, i32, i32, i32)
 // CHECK:STDOUT:   %.loc7_45.2: (i32, i32, i32, i32, i32, i32, i32, i32, i32) = tuple_literal (%.loc7_20, %.loc7_23, %.loc7_26, %.loc7_29, %.loc7_32, %.loc7_35, %.loc7_38, %.loc7_41, %.loc7_44)
 // CHECK:STDOUT:   %.loc7_45.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_45.4: ref i32 = array_index %a, %.loc7_45.3
+// CHECK:STDOUT:   %.loc7_45.4: ref i32 = array_index %a.var, %.loc7_45.3
 // CHECK:STDOUT:   %.loc7_45.5: init i32 = initialize_from %.loc7_20 to %.loc7_45.4
 // CHECK:STDOUT:   %.loc7_45.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc7_45.7: ref i32 = array_index %a, %.loc7_45.6
+// CHECK:STDOUT:   %.loc7_45.7: ref i32 = array_index %a.var, %.loc7_45.6
 // CHECK:STDOUT:   %.loc7_45.8: init i32 = initialize_from %.loc7_23 to %.loc7_45.7
 // CHECK:STDOUT:   %.loc7_45.9: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc7_45.10: ref i32 = array_index %a, %.loc7_45.9
+// CHECK:STDOUT:   %.loc7_45.10: ref i32 = array_index %a.var, %.loc7_45.9
 // CHECK:STDOUT:   %.loc7_45.11: init i32 = initialize_from %.loc7_26 to %.loc7_45.10
 // CHECK:STDOUT:   %.loc7_45.12: i32 = int_literal 3
-// CHECK:STDOUT:   %.loc7_45.13: ref i32 = array_index %a, %.loc7_45.12
+// CHECK:STDOUT:   %.loc7_45.13: ref i32 = array_index %a.var, %.loc7_45.12
 // CHECK:STDOUT:   %.loc7_45.14: init i32 = initialize_from %.loc7_29 to %.loc7_45.13
 // CHECK:STDOUT:   %.loc7_45.15: i32 = int_literal 4
-// CHECK:STDOUT:   %.loc7_45.16: ref i32 = array_index %a, %.loc7_45.15
+// CHECK:STDOUT:   %.loc7_45.16: ref i32 = array_index %a.var, %.loc7_45.15
 // CHECK:STDOUT:   %.loc7_45.17: init i32 = initialize_from %.loc7_32 to %.loc7_45.16
 // CHECK:STDOUT:   %.loc7_45.18: i32 = int_literal 5
-// CHECK:STDOUT:   %.loc7_45.19: ref i32 = array_index %a, %.loc7_45.18
+// CHECK:STDOUT:   %.loc7_45.19: ref i32 = array_index %a.var, %.loc7_45.18
 // CHECK:STDOUT:   %.loc7_45.20: init i32 = initialize_from %.loc7_35 to %.loc7_45.19
 // CHECK:STDOUT:   %.loc7_45.21: i32 = int_literal 6
-// CHECK:STDOUT:   %.loc7_45.22: ref i32 = array_index %a, %.loc7_45.21
+// CHECK:STDOUT:   %.loc7_45.22: ref i32 = array_index %a.var, %.loc7_45.21
 // CHECK:STDOUT:   %.loc7_45.23: init i32 = initialize_from %.loc7_38 to %.loc7_45.22
 // CHECK:STDOUT:   %.loc7_45.24: i32 = int_literal 7
-// CHECK:STDOUT:   %.loc7_45.25: ref i32 = array_index %a, %.loc7_45.24
+// CHECK:STDOUT:   %.loc7_45.25: ref i32 = array_index %a.var, %.loc7_45.24
 // CHECK:STDOUT:   %.loc7_45.26: init i32 = initialize_from %.loc7_41 to %.loc7_45.25
 // CHECK:STDOUT:   %.loc7_45.27: i32 = int_literal 8
-// CHECK:STDOUT:   %.loc7_45.28: ref i32 = array_index %a, %.loc7_45.27
+// CHECK:STDOUT:   %.loc7_45.28: ref i32 = array_index %a.var, %.loc7_45.27
 // CHECK:STDOUT:   %.loc7_45.29: init i32 = initialize_from %.loc7_44 to %.loc7_45.28
-// CHECK:STDOUT:   %.loc7_45.30: init [i32; 9] = array_init %.loc7_45.2, (%.loc7_45.5, %.loc7_45.8, %.loc7_45.11, %.loc7_45.14, %.loc7_45.17, %.loc7_45.20, %.loc7_45.23, %.loc7_45.26, %.loc7_45.29) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_45.30
+// CHECK:STDOUT:   %.loc7_45.30: init [i32; 9] = array_init %.loc7_45.2, (%.loc7_45.5, %.loc7_45.8, %.loc7_45.11, %.loc7_45.14, %.loc7_45.17, %.loc7_45.20, %.loc7_45.23, %.loc7_45.26, %.loc7_45.29) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_45.30
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/builtin_types.carbon

@@ -10,16 +10,20 @@ var test_str: String = "Test";
 var test_type: type = i32;
 
 // CHECK:STDOUT: file "builtin_types.carbon" {
-// CHECK:STDOUT:   %test_i32: ref i32 = var "test_i32"
+// CHECK:STDOUT:   %test_i32.var: ref i32 = var "test_i32"
+// CHECK:STDOUT:   %test_i32: ref i32 = bind_name "test_i32", %test_i32.var
 // CHECK:STDOUT:   %.loc7: i32 = int_literal 0
-// CHECK:STDOUT:   assign %test_i32, %.loc7
-// CHECK:STDOUT:   %test_f64: ref f64 = var "test_f64"
+// CHECK:STDOUT:   assign %test_i32.var, %.loc7
+// CHECK:STDOUT:   %test_f64.var: ref f64 = var "test_f64"
+// CHECK:STDOUT:   %test_f64: ref f64 = bind_name "test_f64", %test_f64.var
 // CHECK:STDOUT:   %.loc8: f64 = real_literal 1e-1
-// CHECK:STDOUT:   assign %test_f64, %.loc8
+// CHECK:STDOUT:   assign %test_f64.var, %.loc8
 // CHECK:STDOUT:   %.1: type = ptr_type String
-// CHECK:STDOUT:   %test_str: ref String = var "test_str"
+// CHECK:STDOUT:   %test_str.var: ref String = var "test_str"
+// CHECK:STDOUT:   %test_str: ref String = bind_name "test_str", %test_str.var
 // CHECK:STDOUT:   %.loc9: String = string_literal "Test"
-// CHECK:STDOUT:   assign %test_str, %.loc9
-// CHECK:STDOUT:   %test_type: ref type = var "test_type"
-// CHECK:STDOUT:   assign %test_type, i32
+// CHECK:STDOUT:   assign %test_str.var, %.loc9
+// CHECK:STDOUT:   %test_type.var: ref type = var "test_type"
+// CHECK:STDOUT:   %test_type: ref type = bind_name "test_type", %test_type.var
+// CHECK:STDOUT:   assign %test_type.var, i32
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/fail_non_type_as_type.carbon

@@ -10,7 +10,8 @@
 var x: type = 42;
 
 // CHECK:STDOUT: file "fail_non_type_as_type.carbon" {
-// CHECK:STDOUT:   %x: ref type = var "x"
+// CHECK:STDOUT:   %x.var: ref type = var "x"
+// CHECK:STDOUT:   %x: ref type = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10: i32 = int_literal 42
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/fail_qualifier_unsupported.carbon

@@ -11,8 +11,10 @@ var x: i32;
 var y: i32 = x.b;
 
 // CHECK:STDOUT: file "fail_qualifier_unsupported.carbon" {
-// CHECK:STDOUT:   %x: ref i32 = var "x"
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref i32 = name_reference "x", %x
-// CHECK:STDOUT:   assign %y, <error>
+// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/numeric_literals.carbon

@@ -34,7 +34,8 @@ fn F() {
 // CHECK:STDOUT:   %.loc10_19: i32 = int_literal 5
 // CHECK:STDOUT:   %.loc10_20.1: type = array_type %.loc10_19, i32
 // CHECK:STDOUT:   %.loc10_20.2: type = ptr_type [i32; 5]
-// CHECK:STDOUT:   %ints: ref [i32; 5] = var "ints"
+// CHECK:STDOUT:   %ints.var: ref [i32; 5] = var "ints"
+// CHECK:STDOUT:   %ints: ref [i32; 5] = bind_name "ints", %ints.var
 // CHECK:STDOUT:   %.loc11: i32 = int_literal 8
 // CHECK:STDOUT:   %.loc12: i32 = int_literal 9
 // CHECK:STDOUT:   %.loc13: i32 = int_literal 8
@@ -43,26 +44,27 @@ fn F() {
 // CHECK:STDOUT:   %.loc16_3.1: type = tuple_type (i32, i32, i32, i32, i32)
 // CHECK:STDOUT:   %.loc16_3.2: (i32, i32, i32, i32, i32) = tuple_literal (%.loc11, %.loc12, %.loc13, %.loc14, %.loc15)
 // CHECK:STDOUT:   %.loc16_3.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc16_3.4: ref i32 = array_index %ints, %.loc16_3.3
+// CHECK:STDOUT:   %.loc16_3.4: ref i32 = array_index %ints.var, %.loc16_3.3
 // CHECK:STDOUT:   %.loc16_3.5: init i32 = initialize_from %.loc11 to %.loc16_3.4
 // CHECK:STDOUT:   %.loc16_3.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc16_3.7: ref i32 = array_index %ints, %.loc16_3.6
+// CHECK:STDOUT:   %.loc16_3.7: ref i32 = array_index %ints.var, %.loc16_3.6
 // CHECK:STDOUT:   %.loc16_3.8: init i32 = initialize_from %.loc12 to %.loc16_3.7
 // CHECK:STDOUT:   %.loc16_3.9: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc16_3.10: ref i32 = array_index %ints, %.loc16_3.9
+// CHECK:STDOUT:   %.loc16_3.10: ref i32 = array_index %ints.var, %.loc16_3.9
 // CHECK:STDOUT:   %.loc16_3.11: init i32 = initialize_from %.loc13 to %.loc16_3.10
 // CHECK:STDOUT:   %.loc16_3.12: i32 = int_literal 3
-// CHECK:STDOUT:   %.loc16_3.13: ref i32 = array_index %ints, %.loc16_3.12
+// CHECK:STDOUT:   %.loc16_3.13: ref i32 = array_index %ints.var, %.loc16_3.12
 // CHECK:STDOUT:   %.loc16_3.14: init i32 = initialize_from %.loc14 to %.loc16_3.13
 // CHECK:STDOUT:   %.loc16_3.15: i32 = int_literal 4
-// CHECK:STDOUT:   %.loc16_3.16: ref i32 = array_index %ints, %.loc16_3.15
+// CHECK:STDOUT:   %.loc16_3.16: ref i32 = array_index %ints.var, %.loc16_3.15
 // CHECK:STDOUT:   %.loc16_3.17: init i32 = initialize_from %.loc15 to %.loc16_3.16
-// CHECK:STDOUT:   %.loc16_3.18: init [i32; 5] = array_init %.loc16_3.2, (%.loc16_3.5, %.loc16_3.8, %.loc16_3.11, %.loc16_3.14, %.loc16_3.17) to %ints
-// CHECK:STDOUT:   assign %ints, %.loc16_3.18
+// CHECK:STDOUT:   %.loc16_3.18: init [i32; 5] = array_init %.loc16_3.2, (%.loc16_3.5, %.loc16_3.8, %.loc16_3.11, %.loc16_3.14, %.loc16_3.17) to %ints.var
+// CHECK:STDOUT:   assign %ints.var, %.loc16_3.18
 // CHECK:STDOUT:   %.loc17_21: i32 = int_literal 7
 // CHECK:STDOUT:   %.loc17_22.1: type = array_type %.loc17_21, f64
 // CHECK:STDOUT:   %.loc17_22.2: type = ptr_type [f64; 7]
-// CHECK:STDOUT:   %floats: ref [f64; 7] = var "floats"
+// CHECK:STDOUT:   %floats.var: ref [f64; 7] = var "floats"
+// CHECK:STDOUT:   %floats: ref [f64; 7] = bind_name "floats", %floats.var
 // CHECK:STDOUT:   %.loc18: f64 = real_literal 9e-1
 // CHECK:STDOUT:   %.loc19: f64 = real_literal 80e-1
 // CHECK:STDOUT:   %.loc20: f64 = real_literal 800e-1
@@ -73,27 +75,27 @@ fn F() {
 // CHECK:STDOUT:   %.loc25_3.1: type = tuple_type (f64, f64, f64, f64, f64, f64, f64)
 // CHECK:STDOUT:   %.loc25_3.2: (f64, f64, f64, f64, f64, f64, f64) = tuple_literal (%.loc18, %.loc19, %.loc20, %.loc21, %.loc22, %.loc23, %.loc24)
 // CHECK:STDOUT:   %.loc25_3.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc25_3.4: ref f64 = array_index %floats, %.loc25_3.3
+// CHECK:STDOUT:   %.loc25_3.4: ref f64 = array_index %floats.var, %.loc25_3.3
 // CHECK:STDOUT:   %.loc25_3.5: init f64 = initialize_from %.loc18 to %.loc25_3.4
 // CHECK:STDOUT:   %.loc25_3.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc25_3.7: ref f64 = array_index %floats, %.loc25_3.6
+// CHECK:STDOUT:   %.loc25_3.7: ref f64 = array_index %floats.var, %.loc25_3.6
 // CHECK:STDOUT:   %.loc25_3.8: init f64 = initialize_from %.loc19 to %.loc25_3.7
 // CHECK:STDOUT:   %.loc25_3.9: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc25_3.10: ref f64 = array_index %floats, %.loc25_3.9
+// CHECK:STDOUT:   %.loc25_3.10: ref f64 = array_index %floats.var, %.loc25_3.9
 // CHECK:STDOUT:   %.loc25_3.11: init f64 = initialize_from %.loc20 to %.loc25_3.10
 // CHECK:STDOUT:   %.loc25_3.12: i32 = int_literal 3
-// CHECK:STDOUT:   %.loc25_3.13: ref f64 = array_index %floats, %.loc25_3.12
+// CHECK:STDOUT:   %.loc25_3.13: ref f64 = array_index %floats.var, %.loc25_3.12
 // CHECK:STDOUT:   %.loc25_3.14: init f64 = initialize_from %.loc21 to %.loc25_3.13
 // CHECK:STDOUT:   %.loc25_3.15: i32 = int_literal 4
-// CHECK:STDOUT:   %.loc25_3.16: ref f64 = array_index %floats, %.loc25_3.15
+// CHECK:STDOUT:   %.loc25_3.16: ref f64 = array_index %floats.var, %.loc25_3.15
 // CHECK:STDOUT:   %.loc25_3.17: init f64 = initialize_from %.loc22 to %.loc25_3.16
 // CHECK:STDOUT:   %.loc25_3.18: i32 = int_literal 5
-// CHECK:STDOUT:   %.loc25_3.19: ref f64 = array_index %floats, %.loc25_3.18
+// CHECK:STDOUT:   %.loc25_3.19: ref f64 = array_index %floats.var, %.loc25_3.18
 // CHECK:STDOUT:   %.loc25_3.20: init f64 = initialize_from %.loc23 to %.loc25_3.19
 // CHECK:STDOUT:   %.loc25_3.21: i32 = int_literal 6
-// CHECK:STDOUT:   %.loc25_3.22: ref f64 = array_index %floats, %.loc25_3.21
+// CHECK:STDOUT:   %.loc25_3.22: ref f64 = array_index %floats.var, %.loc25_3.21
 // CHECK:STDOUT:   %.loc25_3.23: init f64 = initialize_from %.loc24 to %.loc25_3.22
-// CHECK:STDOUT:   %.loc25_3.24: init [f64; 7] = array_init %.loc25_3.2, (%.loc25_3.5, %.loc25_3.8, %.loc25_3.11, %.loc25_3.14, %.loc25_3.17, %.loc25_3.20, %.loc25_3.23) to %floats
-// CHECK:STDOUT:   assign %floats, %.loc25_3.24
+// CHECK:STDOUT:   %.loc25_3.24: init [f64; 7] = array_init %.loc25_3.2, (%.loc25_3.5, %.loc25_3.8, %.loc25_3.11, %.loc25_3.14, %.loc25_3.17, %.loc25_3.20, %.loc25_3.23) to %floats.var
+// CHECK:STDOUT:   assign %floats.var, %.loc25_3.24
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/basics/parens.carbon

@@ -7,9 +7,10 @@
 var test_i32: i32 = ((1) + (2));
 
 // CHECK:STDOUT: file "parens.carbon" {
-// CHECK:STDOUT:   %test_i32: ref i32 = var "test_i32"
+// CHECK:STDOUT:   %test_i32.var: ref i32 = var "test_i32"
+// CHECK:STDOUT:   %test_i32: ref i32 = bind_name "test_i32", %test_i32.var
 // CHECK:STDOUT:   %.loc7_23: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_29: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_26: i32 = add %.loc7_23, %.loc7_29
-// CHECK:STDOUT:   assign %test_i32, %.loc7_26
+// CHECK:STDOUT:   assign %test_i32.var, %.loc7_26
 // CHECK:STDOUT: }

toolchain/check/testdata/class/basic.carbon

@@ -32,7 +32,9 @@ fn Run() -> i32 {
 // CHECK:STDOUT: class @Class {
 // CHECK:STDOUT:   %F: <function> = fn_decl @F
 // CHECK:STDOUT:   %G: <function> = fn_decl @G
-// CHECK:STDOUT:   %k: ref i32 = var "k"
+// CHECK:STDOUT:   %.loc14_8.1: type = unbound_field_type Class, i32
+// CHECK:STDOUT:   %.loc14_8.2: <unbound field of class Class> = field "k"
+// CHECK:STDOUT:   %k: <unbound field of class Class> = bind_name "k", %.loc14_8.2
 // CHECK:STDOUT:
 // CHECK:STDOUT: !members:
 // CHECK:STDOUT:   .F = %F

toolchain/check/testdata/class/fail_incomplete.carbon

@@ -124,7 +124,8 @@ fn CallReturnIncomplete() {
 // CHECK:STDOUT:   %.loc15: <function> = fn_decl @.1
 // CHECK:STDOUT:   %CallClassFunction: <function> = fn_decl @CallClassFunction
 // CHECK:STDOUT:   %Class.ref: type = name_reference "Class", %Class
-// CHECK:STDOUT:   %global_var: ref <error> = var "global_var"
+// CHECK:STDOUT:   %global_var.var: ref <error> = var "global_var"
+// CHECK:STDOUT:   %global_var: ref <error> = bind_name "global_var", %global_var.var
 // CHECK:STDOUT:   %ConvertFromStruct: <function> = fn_decl @ConvertFromStruct
 // CHECK:STDOUT:   %MemberAccess: <function> = fn_decl @MemberAccess
 // CHECK:STDOUT:   %Copy: <function> = fn_decl @Copy

toolchain/check/testdata/class/fail_unbound_field.carbon

@@ -0,0 +1,53 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// AUTOUPDATE
+
+class Class {
+  var field: i32;
+  fn F() -> i32 {
+    // TODO: Unqualified lookup should find this name.
+    // CHECK:STDERR: fail_unbound_field.carbon:[[@LINE+3]]:12: ERROR: Name `field` not found.
+    // CHECK:STDERR:     return field;
+    // CHECK:STDERR:            ^
+    return field;
+  }
+}
+
+fn G() -> i32 {
+  // CHECK:STDERR: fail_unbound_field.carbon:[[@LINE+3]]:15: ERROR: Expression cannot be used as a value.
+  // CHECK:STDERR:   return Class.field;
+  // CHECK:STDERR:               ^
+  return Class.field;
+}
+
+// CHECK:STDOUT: file "fail_unbound_field.carbon" {
+// CHECK:STDOUT:   class_declaration @Class, ()
+// CHECK:STDOUT:   %Class: type = class_type @Class
+// CHECK:STDOUT:   %G: <function> = fn_decl @G
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: class @Class {
+// CHECK:STDOUT:   %.loc8_12.1: type = unbound_field_type Class, i32
+// CHECK:STDOUT:   %.loc8_12.2: <unbound field of class Class> = field "field"
+// CHECK:STDOUT:   %field: <unbound field of class Class> = bind_name "field", %.loc8_12.2
+// CHECK:STDOUT:   %F: <function> = fn_decl @F
+// CHECK:STDOUT:
+// CHECK:STDOUT: !members:
+// CHECK:STDOUT:   .field = %field
+// CHECK:STDOUT:   .F = %F
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @F() -> i32 {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %field.ref: <error> = name_reference "field", <error>
+// CHECK:STDOUT:   return <error>
+// CHECK:STDOUT: }
+// CHECK:STDOUT:
+// CHECK:STDOUT: fn @G() -> i32 {
+// CHECK:STDOUT: !entry:
+// CHECK:STDOUT:   %Class.ref: type = name_reference "Class", file.%Class
+// CHECK:STDOUT:   %field.ref: <unbound field of class Class> = name_reference "field", @Class.%field
+// CHECK:STDOUT:   return <error>
+// CHECK:STDOUT: }

toolchain/check/testdata/expression_category/in_place_tuple_initialization.carbon

@@ -28,11 +28,12 @@ fn H() -> i32 {
 // CHECK:STDOUT: fn @G() -> %return: (i32, i32) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_19: (type, type) = tuple_literal (i32, i32)
-// CHECK:STDOUT:   %v: ref (i32, i32) = var "v"
+// CHECK:STDOUT:   %v.var: ref (i32, i32) = var "v"
+// CHECK:STDOUT:   %v: ref (i32, i32) = bind_name "v", %v.var
 // CHECK:STDOUT:   %F.ref.loc10: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc10_7: ref (i32, i32) = splice_block %v {}
+// CHECK:STDOUT:   %.loc10_7: ref (i32, i32) = splice_block %v.var {}
 // CHECK:STDOUT:   %.loc10_24: init (i32, i32) = call %F.ref.loc10() to %.loc10_7
-// CHECK:STDOUT:   assign %v, %.loc10_24
+// CHECK:STDOUT:   assign %v.var, %.loc10_24
 // CHECK:STDOUT:   %v.ref: ref (i32, i32) = name_reference "v", %v
 // CHECK:STDOUT:   %F.ref.loc11: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc11_3: ref (i32, i32) = splice_block %v.ref {}

toolchain/check/testdata/function/call/fail_not_callable.carbon

@@ -20,9 +20,10 @@ fn Run() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Run() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.1: type = ptr_type String
 // CHECK:STDOUT:   %.loc14: String = string_literal "hello"
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon

@@ -26,9 +26,10 @@ fn Run() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Run() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %Foo.ref: <function> = name_reference "Foo", file.%Foo
 // CHECK:STDOUT:   %.loc13: init f64 = call %Foo.ref()
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/i32.carbon

@@ -25,10 +25,11 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %Echo.ref: <function> = name_reference "Echo", file.%Echo
 // CHECK:STDOUT:   %.loc12_21: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc12_20: init i32 = call %Echo.ref(%.loc12_21)
-// CHECK:STDOUT:   assign %b, %.loc12_20
+// CHECK:STDOUT:   assign %b.var, %.loc12_20
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/function/call/return_implicit.carbon

@@ -25,9 +25,10 @@ fn Main() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_11.1: type = tuple_type ()
 // CHECK:STDOUT:   %.loc11_11.2: () = tuple_literal ()
-// CHECK:STDOUT:   %b: ref () = var "b"
+// CHECK:STDOUT:   %b.var: ref () = var "b"
+// CHECK:STDOUT:   %b: ref () = bind_name "b", %b.var
 // CHECK:STDOUT:   %MakeImplicitEmptyTuple.ref: <function> = name_reference "MakeImplicitEmptyTuple", file.%MakeImplicitEmptyTuple
 // CHECK:STDOUT:   %.loc11_37: init () = call %MakeImplicitEmptyTuple.ref()
-// CHECK:STDOUT:   assign %b, %.loc11_37
+// CHECK:STDOUT:   assign %b.var, %.loc11_37
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/if/fail_scope.carbon

@@ -25,9 +25,10 @@ fn VarScope(b: bool) -> i32 {
 // CHECK:STDOUT:   if %b.ref br !if.then else br !if.else
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.then:
-// CHECK:STDOUT:   %n: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var: ref i32 = var "n"
+// CHECK:STDOUT:   %n: ref i32 = bind_name "n", %n.var
 // CHECK:STDOUT:   %.loc9: i32 = int_literal 2
-// CHECK:STDOUT:   assign %n, %.loc9
+// CHECK:STDOUT:   assign %n.var, %.loc9
 // CHECK:STDOUT:   %n.ref.loc10: ref i32 = name_reference "n", %n
 // CHECK:STDOUT:   %.loc10: i32 = bind_value %n.ref.loc10
 // CHECK:STDOUT:   return %.loc10

toolchain/check/testdata/if_expression/struct.carbon

@@ -22,16 +22,17 @@ fn F(cond: bool) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_27: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc7: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %a: ref {.a: i32, .b: i32} = var "a"
+// CHECK:STDOUT:   %a.var: ref {.a: i32, .b: i32} = var "a"
+// CHECK:STDOUT:   %a: ref {.a: i32, .b: i32} = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc10_37: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_45: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_46.1: {.a: i32, .b: i32} = struct_literal (%.loc10_37, %.loc10_45)
-// CHECK:STDOUT:   %.loc10_46.2: ref i32 = struct_access %a, member0
+// CHECK:STDOUT:   %.loc10_46.2: ref i32 = struct_access %a.var, member0
 // CHECK:STDOUT:   %.loc10_46.3: init i32 = initialize_from %.loc10_37 to %.loc10_46.2
-// CHECK:STDOUT:   %.loc10_46.4: ref i32 = struct_access %a, member1
+// CHECK:STDOUT:   %.loc10_46.4: ref i32 = struct_access %a.var, member1
 // CHECK:STDOUT:   %.loc10_46.5: init i32 = initialize_from %.loc10_45 to %.loc10_46.4
 // CHECK:STDOUT:   %.loc10_46.6: init {.a: i32, .b: i32} = struct_init %.loc10_46.1, (%.loc10_46.3, %.loc10_46.5)
-// CHECK:STDOUT:   assign %a, %.loc10_46.6
+// CHECK:STDOUT:   assign %a.var, %.loc10_46.6
 // CHECK:STDOUT:   %G.ref: <function> = name_reference "G", file.%G
 // CHECK:STDOUT:   %cond.ref: bool = name_reference "cond", %cond
 // CHECK:STDOUT:   if %cond.ref br !if.expr.then else br !if.expr.else

toolchain/check/testdata/index/array_element_access.carbon

@@ -13,33 +13,37 @@ var d: i32 = a[b];
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 2]
-// CHECK:STDOUT:   %a: ref [i32; 2] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 2] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 2] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_24: i32 = int_literal 24
 // CHECK:STDOUT:   %.loc7_26.1: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_26.2: (i32, i32) = tuple_literal (%.loc7_20, %.loc7_24)
 // CHECK:STDOUT:   %.loc7_26.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_26.4: ref i32 = array_index %a, %.loc7_26.3
+// CHECK:STDOUT:   %.loc7_26.4: ref i32 = array_index %a.var, %.loc7_26.3
 // CHECK:STDOUT:   %.loc7_26.5: init i32 = initialize_from %.loc7_20 to %.loc7_26.4
 // CHECK:STDOUT:   %.loc7_26.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc7_26.7: ref i32 = array_index %a, %.loc7_26.6
+// CHECK:STDOUT:   %.loc7_26.7: ref i32 = array_index %a.var, %.loc7_26.6
 // CHECK:STDOUT:   %.loc7_26.8: init i32 = initialize_from %.loc7_24 to %.loc7_26.7
-// CHECK:STDOUT:   %.loc7_26.9: init [i32; 2] = array_init %.loc7_26.2, (%.loc7_26.5, %.loc7_26.8) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_26.9
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %.loc7_26.9: init [i32; 2] = array_init %.loc7_26.2, (%.loc7_26.5, %.loc7_26.8) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_26.9
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 1
-// CHECK:STDOUT:   assign %b, %.loc8
-// CHECK:STDOUT:   %c: ref i32 = var "c"
+// CHECK:STDOUT:   assign %b.var, %.loc8
+// CHECK:STDOUT:   %c.var: ref i32 = var "c"
+// CHECK:STDOUT:   %c: ref i32 = bind_name "c", %c.var
 // CHECK:STDOUT:   %a.ref.loc9: ref [i32; 2] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc9_16: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc9_17.1: ref i32 = array_index %a.ref.loc9, %.loc9_16
 // CHECK:STDOUT:   %.loc9_17.2: i32 = bind_value %.loc9_17.1
-// CHECK:STDOUT:   assign %c, %.loc9_17.2
-// CHECK:STDOUT:   %d: ref i32 = var "d"
+// CHECK:STDOUT:   assign %c.var, %.loc9_17.2
+// CHECK:STDOUT:   %d.var: ref i32 = var "d"
+// CHECK:STDOUT:   %d: ref i32 = bind_name "d", %d.var
 // CHECK:STDOUT:   %a.ref.loc10: ref [i32; 2] = name_reference "a", %a
 // CHECK:STDOUT:   %b.ref: ref i32 = name_reference "b", %b
 // CHECK:STDOUT:   %.loc10_16: i32 = bind_value %b.ref
 // CHECK:STDOUT:   %.loc10_17.1: ref i32 = array_index %a.ref.loc10, %.loc10_16
 // CHECK:STDOUT:   %.loc10_17.2: i32 = bind_value %.loc10_17.1
-// CHECK:STDOUT:   assign %d, %.loc10_17.2
+// CHECK:STDOUT:   assign %d.var, %.loc10_17.2
 // CHECK:STDOUT: }

toolchain/check/testdata/index/expression_category.carbon

@@ -37,30 +37,32 @@ fn ValueBinding(b: [i32; 3]) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc10_16: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc10_17: type = array_type %.loc10_16, i32
-// CHECK:STDOUT:   %a: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 3] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_25: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_28: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc10_29.1: type = tuple_type (i32, i32, i32)
 // CHECK:STDOUT:   %.loc10_29.2: (i32, i32, i32) = tuple_literal (%.loc10_22, %.loc10_25, %.loc10_28)
 // CHECK:STDOUT:   %.loc10_29.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc10_29.4: ref i32 = array_index %a, %.loc10_29.3
+// CHECK:STDOUT:   %.loc10_29.4: ref i32 = array_index %a.var, %.loc10_29.3
 // CHECK:STDOUT:   %.loc10_29.5: init i32 = initialize_from %.loc10_22 to %.loc10_29.4
 // CHECK:STDOUT:   %.loc10_29.6: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc10_29.7: ref i32 = array_index %a, %.loc10_29.6
+// CHECK:STDOUT:   %.loc10_29.7: ref i32 = array_index %a.var, %.loc10_29.6
 // CHECK:STDOUT:   %.loc10_29.8: init i32 = initialize_from %.loc10_25 to %.loc10_29.7
 // CHECK:STDOUT:   %.loc10_29.9: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc10_29.10: ref i32 = array_index %a, %.loc10_29.9
+// CHECK:STDOUT:   %.loc10_29.10: ref i32 = array_index %a.var, %.loc10_29.9
 // CHECK:STDOUT:   %.loc10_29.11: init i32 = initialize_from %.loc10_28 to %.loc10_29.10
-// CHECK:STDOUT:   %.loc10_29.12: init [i32; 3] = array_init %.loc10_29.2, (%.loc10_29.5, %.loc10_29.8, %.loc10_29.11) to %a
-// CHECK:STDOUT:   assign %a, %.loc10_29.12
+// CHECK:STDOUT:   %.loc10_29.12: init [i32; 3] = array_init %.loc10_29.2, (%.loc10_29.5, %.loc10_29.8, %.loc10_29.11) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc10_29.12
 // CHECK:STDOUT:   %.loc13_14: type = ptr_type i32
-// CHECK:STDOUT:   %pa: ref i32* = var "pa"
+// CHECK:STDOUT:   %pa.var: ref i32* = var "pa"
+// CHECK:STDOUT:   %pa: ref i32* = bind_name "pa", %pa.var
 // CHECK:STDOUT:   %a.ref.loc13: ref [i32; 3] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc13_21: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc13_22: ref i32 = array_index %a.ref.loc13, %.loc13_21
 // CHECK:STDOUT:   %.loc13_18: i32* = address_of %.loc13_22
-// CHECK:STDOUT:   assign %pa, %.loc13_18
+// CHECK:STDOUT:   assign %pa.var, %.loc13_18
 // CHECK:STDOUT:   %a.ref.loc14: ref [i32; 3] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc14_5: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc14_6: ref i32 = array_index %a.ref.loc14, %.loc14_5
@@ -73,22 +75,23 @@ fn ValueBinding(b: [i32; 3]) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc18_16: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc18_17: type = array_type %.loc18_16, i32
-// CHECK:STDOUT:   %a: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 3] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 3] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc18_22: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc18_25: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc18_28: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc18_29.1: (i32, i32, i32) = tuple_literal (%.loc18_22, %.loc18_25, %.loc18_28)
 // CHECK:STDOUT:   %.loc18_29.2: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc18_29.3: ref i32 = array_index %a, %.loc18_29.2
+// CHECK:STDOUT:   %.loc18_29.3: ref i32 = array_index %a.var, %.loc18_29.2
 // CHECK:STDOUT:   %.loc18_29.4: init i32 = initialize_from %.loc18_22 to %.loc18_29.3
 // CHECK:STDOUT:   %.loc18_29.5: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc18_29.6: ref i32 = array_index %a, %.loc18_29.5
+// CHECK:STDOUT:   %.loc18_29.6: ref i32 = array_index %a.var, %.loc18_29.5
 // CHECK:STDOUT:   %.loc18_29.7: init i32 = initialize_from %.loc18_25 to %.loc18_29.6
 // CHECK:STDOUT:   %.loc18_29.8: i32 = int_literal 2
-// CHECK:STDOUT:   %.loc18_29.9: ref i32 = array_index %a, %.loc18_29.8
+// CHECK:STDOUT:   %.loc18_29.9: ref i32 = array_index %a.var, %.loc18_29.8
 // CHECK:STDOUT:   %.loc18_29.10: init i32 = initialize_from %.loc18_28 to %.loc18_29.9
-// CHECK:STDOUT:   %.loc18_29.11: init [i32; 3] = array_init %.loc18_29.1, (%.loc18_29.4, %.loc18_29.7, %.loc18_29.10) to %a
-// CHECK:STDOUT:   assign %a, %.loc18_29.11
+// CHECK:STDOUT:   %.loc18_29.11: init [i32; 3] = array_init %.loc18_29.1, (%.loc18_29.4, %.loc18_29.7, %.loc18_29.10) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc18_29.11
 // CHECK:STDOUT:   %a.ref: ref [i32; 3] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc22_5: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc22_6: ref i32 = array_index %a.ref, %.loc22_5

toolchain/check/testdata/index/fail_array_large_index.carbon

@@ -14,19 +14,21 @@ var b: i32 = a[0xFFFFFFFFFFFFFFFFF];
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %a: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 1] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_23.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc7_23.2: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a, %.loc7_23.3
+// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a.var, %.loc7_23.3
 // CHECK:STDOUT:   %.loc7_23.5: init i32 = initialize_from %.loc7_20 to %.loc7_23.4
-// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_23.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 295147905179352825855
 // CHECK:STDOUT:   %.loc11_35.1: ref i32 = array_index %a.ref, <error>
 // CHECK:STDOUT:   %.loc11_35.2: i32 = bind_value %.loc11_35.1
-// CHECK:STDOUT:   assign %b, %.loc11_35.2
+// CHECK:STDOUT:   assign %b.var, %.loc11_35.2
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_array_non_int_indexing.carbon

@@ -14,19 +14,21 @@ var b: i32 = a[2.6];
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %a: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 1] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_23.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc7_23.2: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a, %.loc7_23.3
+// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a.var, %.loc7_23.3
 // CHECK:STDOUT:   %.loc7_23.5: init i32 = initialize_from %.loc7_20 to %.loc7_23.4
-// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_23.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc11_16: f64 = real_literal 26e-1
 // CHECK:STDOUT:   %.loc11_19.1: ref i32 = array_index %a.ref, <error>
 // CHECK:STDOUT:   %.loc11_19.2: i32 = bind_value %.loc11_19.1
-// CHECK:STDOUT:   assign %b, %.loc11_19.2
+// CHECK:STDOUT:   assign %b.var, %.loc11_19.2
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_array_out_of_bound_access.carbon

@@ -14,19 +14,21 @@ var b: i32 = a[2];
 // CHECK:STDOUT:   %.loc7_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_15.1: type = array_type %.loc7_14, i32
 // CHECK:STDOUT:   %.loc7_15.2: type = ptr_type [i32; 1]
-// CHECK:STDOUT:   %a: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a.var: ref [i32; 1] = var "a"
+// CHECK:STDOUT:   %a: ref [i32; 1] = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_20: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_23.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc7_23.2: (i32,) = tuple_literal (%.loc7_20)
 // CHECK:STDOUT:   %.loc7_23.3: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a, %.loc7_23.3
+// CHECK:STDOUT:   %.loc7_23.4: ref i32 = array_index %a.var, %.loc7_23.3
 // CHECK:STDOUT:   %.loc7_23.5: init i32 = initialize_from %.loc7_20 to %.loc7_23.4
-// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a
-// CHECK:STDOUT:   assign %a, %.loc7_23.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %.loc7_23.6: init [i32; 1] = array_init %.loc7_23.2, (%.loc7_23.5) to %a.var
+// CHECK:STDOUT:   assign %a.var, %.loc7_23.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref [i32; 1] = name_reference "a", %a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc11_17.1: ref i32 = array_index %a.ref, <error>
 // CHECK:STDOUT:   %.loc11_17.2: i32 = bind_value %.loc11_17.1
-// CHECK:STDOUT:   assign %b, %.loc11_17.2
+// CHECK:STDOUT:   assign %b.var, %.loc11_17.2
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_expression_category.carbon

@@ -40,14 +40,15 @@ fn G(b: [i32; 3]) {
 // CHECK:STDOUT: fn @G(%b: [i32; 3]) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc14_14: type = ptr_type i32
-// CHECK:STDOUT:   %pb: ref i32* = var "pb"
+// CHECK:STDOUT:   %pb.var: ref i32* = var "pb"
+// CHECK:STDOUT:   %pb: ref i32* = bind_name "pb", %pb.var
 // CHECK:STDOUT:   %b.ref.loc14: [i32; 3] = name_reference "b", %b
 // CHECK:STDOUT:   %.loc14_21: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc14_22.1: ref [i32; 3] = value_as_reference %b.ref.loc14
 // CHECK:STDOUT:   %.loc14_22.2: ref i32 = array_index %.loc14_22.1, %.loc14_21
 // CHECK:STDOUT:   %.loc14_22.3: i32 = bind_value %.loc14_22.2
 // CHECK:STDOUT:   %.loc14_18: i32* = address_of %.loc14_22.3
-// CHECK:STDOUT:   assign %pb, %.loc14_18
+// CHECK:STDOUT:   assign %pb.var, %.loc14_18
 // CHECK:STDOUT:   %b.ref.loc18: [i32; 3] = name_reference "b", %b
 // CHECK:STDOUT:   %.loc18_5: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc18_6.1: ref [i32; 3] = value_as_reference %b.ref.loc18
@@ -56,7 +57,8 @@ fn G(b: [i32; 3]) {
 // CHECK:STDOUT:   %.loc18_10: i32 = int_literal 4
 // CHECK:STDOUT:   assign %.loc18_6.3, %.loc18_10
 // CHECK:STDOUT:   %.loc25_14: type = ptr_type i32
-// CHECK:STDOUT:   %pf: ref i32* = var "pf"
+// CHECK:STDOUT:   %pf.var: ref i32* = var "pf"
+// CHECK:STDOUT:   %pf: ref i32* = bind_name "pf", %pf.var
 // CHECK:STDOUT:   %F.ref.loc25: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc25_20.1: ref [i32; 3] = temporary_storage
 // CHECK:STDOUT:   %.loc25_20.2: init [i32; 3] = call %F.ref.loc25() to %.loc25_20.1
@@ -65,7 +67,7 @@ fn G(b: [i32; 3]) {
 // CHECK:STDOUT:   %.loc25_24.1: ref i32 = array_index %.loc25_20.3, %.loc25_23
 // CHECK:STDOUT:   %.loc25_24.2: i32 = bind_value %.loc25_24.1
 // CHECK:STDOUT:   %.loc25_18: i32* = address_of %.loc25_24.2
-// CHECK:STDOUT:   assign %pf, %.loc25_18
+// CHECK:STDOUT:   assign %pf.var, %.loc25_18
 // CHECK:STDOUT:   %F.ref.loc29: <function> = name_reference "F", file.%F
 // CHECK:STDOUT:   %.loc29_4.1: ref [i32; 3] = temporary_storage
 // CHECK:STDOUT:   %.loc29_4.2: init [i32; 3] = call %F.ref.loc29() to %.loc29_4.1

toolchain/check/testdata/index/fail_invalid_base.carbon

@@ -32,16 +32,19 @@ var d: i32 = {.a: i32, .b: i32}[0];
 
 // CHECK:STDOUT: file "fail_invalid_base.carbon" {
 // CHECK:STDOUT:   %.loc11: <namespace> = namespace {}
-// CHECK:STDOUT:   %a: ref i32 = var "a"
+// CHECK:STDOUT:   %a.var: ref i32 = var "a"
+// CHECK:STDOUT:   %a: ref i32 = bind_name "a", %a.var
 // CHECK:STDOUT:   %N.ref: <namespace> = name_reference "N", %.loc11
 // CHECK:STDOUT:   %.loc15: i32 = int_literal 0
-// CHECK:STDOUT:   assign %a, <error>
+// CHECK:STDOUT:   assign %a.var, <error>
 // CHECK:STDOUT:   %F: <function> = fn_decl @F
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %F.ref: <function> = name_reference "F", %F
 // CHECK:STDOUT:   %.loc21: i32 = int_literal 1
-// CHECK:STDOUT:   assign %b, <error>
-// CHECK:STDOUT:   %c: ref i32 = var "c"
+// CHECK:STDOUT:   assign %b.var, <error>
+// CHECK:STDOUT:   %c.var: ref i32 = var "c"
+// CHECK:STDOUT:   %c: ref i32 = bind_name "c", %c.var
 // CHECK:STDOUT:   %.loc26_20: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc26_28: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc26_29.1: type = struct_type {.a: i32, .b: i32}
@@ -49,11 +52,12 @@ var d: i32 = {.a: i32, .b: i32}[0];
 // CHECK:STDOUT:   %.loc26_31: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc26_29.3: type = ptr_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc26_29.4: {.a: i32, .b: i32} = struct_value %.loc26_29.2, (%.loc26_20, %.loc26_28)
-// CHECK:STDOUT:   assign %c, <error>
-// CHECK:STDOUT:   %d: ref i32 = var "d"
+// CHECK:STDOUT:   assign %c.var, <error>
+// CHECK:STDOUT:   %d.var: ref i32 = var "d"
+// CHECK:STDOUT:   %d: ref i32 = bind_name "d", %d.var
 // CHECK:STDOUT:   %.loc31_31: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc31_33: i32 = int_literal 0
-// CHECK:STDOUT:   assign %d, <error>
+// CHECK:STDOUT:   assign %d.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F();

toolchain/check/testdata/index/fail_name_not_found.carbon

@@ -17,9 +17,10 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: <error> = name_reference "a", <error>
 // CHECK:STDOUT:   %.loc11: i32 = int_literal 0
-// CHECK:STDOUT:   assign %b, <error>
+// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_non_deterministic_type.carbon

@@ -16,22 +16,25 @@ var c: i32 = a[b];
 // CHECK:STDOUT:   %.loc7_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %a: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a: ref (i32, i32) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_25: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc7_26.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_25)
-// CHECK:STDOUT:   %.loc7_26.2: ref i32 = tuple_access %a, member0
+// CHECK:STDOUT:   %.loc7_26.2: ref i32 = tuple_access %a.var, member0
 // CHECK:STDOUT:   %.loc7_26.3: init i32 = initialize_from %.loc7_22 to %.loc7_26.2
-// CHECK:STDOUT:   %.loc7_26.4: ref i32 = tuple_access %a, member1
+// CHECK:STDOUT:   %.loc7_26.4: ref i32 = tuple_access %a.var, member1
 // CHECK:STDOUT:   %.loc7_26.5: init i32 = initialize_from %.loc7_25 to %.loc7_26.4
 // CHECK:STDOUT:   %.loc7_26.6: init (i32, i32) = tuple_init %.loc7_26.1, (%.loc7_26.3, %.loc7_26.5)
-// CHECK:STDOUT:   assign %a, %.loc7_26.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   assign %a.var, %.loc7_26.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
-// CHECK:STDOUT:   assign %b, %.loc8
-// CHECK:STDOUT:   %c: ref i32 = var "c"
+// CHECK:STDOUT:   assign %b.var, %.loc8
+// CHECK:STDOUT:   %c.var: ref i32 = var "c"
+// CHECK:STDOUT:   %c: ref i32 = bind_name "c", %c.var
 // CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_reference "a", %a
 // CHECK:STDOUT:   %b.ref: ref i32 = name_reference "b", %b
 // CHECK:STDOUT:   %.loc12: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %c, <error>
+// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_tuple_index_error.carbon

@@ -15,19 +15,21 @@ var b: i32 = a[oops];
 // CHECK:STDOUT:   %.loc7_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %a: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a: ref (i32, i32) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a, member0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, member0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a, member1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, member1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4
 // CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init %.loc7_27.1, (%.loc7_27.3, %.loc7_27.5)
-// CHECK:STDOUT:   assign %a, %.loc7_27.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   assign %a.var, %.loc7_27.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_reference "a", %a
 // CHECK:STDOUT:   %oops.ref: <error> = name_reference "oops", <error>
 // CHECK:STDOUT:   %.loc11: ref <error> = tuple_index %a.ref, %oops.ref
-// CHECK:STDOUT:   assign %b, <error>
+// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_tuple_large_index.carbon

@@ -15,21 +15,24 @@ var c: i32 = b[0xFFFFFFFFFFFFFFFFF];
 // CHECK:STDOUT:   %.loc7_13.1: type = tuple_type (type)
 // CHECK:STDOUT:   %.loc7_13.2: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc7_13.3: type = tuple_type (i32)
-// CHECK:STDOUT:   %a: ref (i32,) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32,) = var "a"
+// CHECK:STDOUT:   %a: ref (i32,) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
 // CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init %.loc7_21.1, (%.loc7_18)
-// CHECK:STDOUT:   assign %a, %.loc7_21.2
+// CHECK:STDOUT:   assign %a.var, %.loc7_21.2
 // CHECK:STDOUT:   %.loc8_13: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   %b: ref (i32,) = var "b"
+// CHECK:STDOUT:   %b.var: ref (i32,) = var "b"
+// CHECK:STDOUT:   %b: ref (i32,) = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32,) = name_reference "a", %a
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %a.ref, member0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
 // CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init %a.ref, (%.loc8_17.2)
-// CHECK:STDOUT:   assign %b, %.loc8_17.3
-// CHECK:STDOUT:   %c: ref i32 = var "c"
+// CHECK:STDOUT:   assign %b.var, %.loc8_17.3
+// CHECK:STDOUT:   %c.var: ref i32 = var "c"
+// CHECK:STDOUT:   %c: ref i32 = bind_name "c", %c.var
 // CHECK:STDOUT:   %b.ref: ref (i32,) = name_reference "b", %b
 // CHECK:STDOUT:   %.loc12_16: i32 = int_literal 295147905179352825855
 // CHECK:STDOUT:   %.loc12_35: ref <error> = tuple_index %b.ref, <error>
-// CHECK:STDOUT:   assign %c, <error>
+// CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_tuple_non_int_indexing.carbon

@@ -15,19 +15,21 @@ var b: i32 = a[2.6];
 // CHECK:STDOUT:   %.loc7_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %a: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a: ref (i32, i32) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a, member0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, member0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a, member1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, member1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4
 // CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init %.loc7_27.1, (%.loc7_27.3, %.loc7_27.5)
-// CHECK:STDOUT:   assign %a, %.loc7_27.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   assign %a.var, %.loc7_27.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_reference "a", %a
 // CHECK:STDOUT:   %.loc11_16: f64 = real_literal 26e-1
 // CHECK:STDOUT:   %.loc11_19: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b, <error>
+// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/index/fail_tuple_out_of_bound_access.carbon

@@ -15,19 +15,21 @@ var b: i32 = a[2];
 // CHECK:STDOUT:   %.loc7_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %a: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32, i32) = var "a"
+// CHECK:STDOUT:   %a: ref (i32, i32) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 6
 // CHECK:STDOUT:   %.loc7_27.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_26)
-// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a, member0
+// CHECK:STDOUT:   %.loc7_27.2: ref i32 = tuple_access %a.var, member0
 // CHECK:STDOUT:   %.loc7_27.3: init i32 = initialize_from %.loc7_22 to %.loc7_27.2
-// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a, member1
+// CHECK:STDOUT:   %.loc7_27.4: ref i32 = tuple_access %a.var, member1
 // CHECK:STDOUT:   %.loc7_27.5: init i32 = initialize_from %.loc7_26 to %.loc7_27.4
 // CHECK:STDOUT:   %.loc7_27.6: init (i32, i32) = tuple_init %.loc7_27.1, (%.loc7_27.3, %.loc7_27.5)
-// CHECK:STDOUT:   assign %a, %.loc7_27.6
-// CHECK:STDOUT:   %b: ref i32 = var "b"
+// CHECK:STDOUT:   assign %a.var, %.loc7_27.6
+// CHECK:STDOUT:   %b.var: ref i32 = var "b"
+// CHECK:STDOUT:   %b: ref i32 = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32, i32) = name_reference "a", %a
 // CHECK:STDOUT:   %.loc11_16: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc11_17: ref <error> = tuple_index %a.ref, <error>
-// CHECK:STDOUT:   assign %b, <error>
+// CHECK:STDOUT:   assign %b.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/index/tuple_element_access.carbon

@@ -12,22 +12,25 @@ var c: i32 = b[0];
 // CHECK:STDOUT:   %.loc7_13.1: type = tuple_type (type)
 // CHECK:STDOUT:   %.loc7_13.2: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc7_13.3: type = tuple_type (i32)
-// CHECK:STDOUT:   %a: ref (i32,) = var "a"
+// CHECK:STDOUT:   %a.var: ref (i32,) = var "a"
+// CHECK:STDOUT:   %a: ref (i32,) = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc7_18: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_21.1: (i32,) = tuple_literal (%.loc7_18)
 // CHECK:STDOUT:   %.loc7_21.2: init (i32,) = tuple_init %.loc7_21.1, (%.loc7_18)
-// CHECK:STDOUT:   assign %a, %.loc7_21.2
+// CHECK:STDOUT:   assign %a.var, %.loc7_21.2
 // CHECK:STDOUT:   %.loc8_13: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   %b: ref (i32,) = var "b"
+// CHECK:STDOUT:   %b.var: ref (i32,) = var "b"
+// CHECK:STDOUT:   %b: ref (i32,) = bind_name "b", %b.var
 // CHECK:STDOUT:   %a.ref: ref (i32,) = name_reference "a", %a
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %a.ref, member0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
 // CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init %a.ref, (%.loc8_17.2)
-// CHECK:STDOUT:   assign %b, %.loc8_17.3
-// CHECK:STDOUT:   %c: ref i32 = var "c"
+// CHECK:STDOUT:   assign %b.var, %.loc8_17.3
+// CHECK:STDOUT:   %c.var: ref i32 = var "c"
+// CHECK:STDOUT:   %c: ref i32 = bind_name "c", %c.var
 // CHECK:STDOUT:   %b.ref: ref (i32,) = name_reference "b", %b
 // CHECK:STDOUT:   %.loc9_16: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc9_17.1: ref i32 = tuple_index %b.ref, %.loc9_16
 // CHECK:STDOUT:   %.loc9_17.2: i32 = bind_value %.loc9_17.1
-// CHECK:STDOUT:   assign %c, %.loc9_17.2
+// CHECK:STDOUT:   assign %c.var, %.loc9_17.2
 // CHECK:STDOUT: }

toolchain/check/testdata/ir/duplicate_name_same_line.carbon

@@ -16,9 +16,10 @@ fn A() { if (true) { var n: i32 = 1; } if (true) { var n: i32 = 2; } }
 // CHECK:STDOUT:   if %.loc7_14 br !if.then.loc7_18 else br !if.else.loc7_18
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.then.loc7_18:
-// CHECK:STDOUT:   %n.loc7_26: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var.loc7_26: ref i32 = var "n"
+// CHECK:STDOUT:   %n.loc7_26: ref i32 = bind_name "n", %n.var.loc7_26
 // CHECK:STDOUT:   %.loc7_35: i32 = int_literal 1
-// CHECK:STDOUT:   assign %n.loc7_26, %.loc7_35
+// CHECK:STDOUT:   assign %n.var.loc7_26, %.loc7_35
 // CHECK:STDOUT:   br !if.else.loc7_18
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.else.loc7_18:
@@ -26,9 +27,10 @@ fn A() { if (true) { var n: i32 = 1; } if (true) { var n: i32 = 2; } }
 // CHECK:STDOUT:   if %.loc7_44 br !if.then.loc7_48 else br !if.else.loc7_48
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.then.loc7_48:
-// CHECK:STDOUT:   %n.loc7_56: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var.loc7_56: ref i32 = var "n"
+// CHECK:STDOUT:   %n.loc7_56: ref i32 = bind_name "n", %n.var.loc7_56
 // CHECK:STDOUT:   %.loc7_65: i32 = int_literal 2
-// CHECK:STDOUT:   assign %n.loc7_56, %.loc7_65
+// CHECK:STDOUT:   assign %n.var.loc7_56, %.loc7_65
 // CHECK:STDOUT:   br !if.else.loc7_48
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.else.loc7_48:

toolchain/check/testdata/let/convert.carbon

@@ -21,19 +21,20 @@ fn F() -> i32 {
 // CHECK:STDOUT:   %.loc8_24.2: (type, type, type) = tuple_literal (i32, i32, i32)
 // CHECK:STDOUT:   %.loc8_24.3: type = tuple_type (i32, i32, i32)
 // CHECK:STDOUT:   %.loc8_24.4: type = ptr_type (i32, i32, i32)
-// CHECK:STDOUT:   %v: ref (i32, i32, i32) = var "v"
+// CHECK:STDOUT:   %v.var: ref (i32, i32, i32) = var "v"
+// CHECK:STDOUT:   %v: ref (i32, i32, i32) = bind_name "v", %v.var
 // CHECK:STDOUT:   %.loc8_29: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc8_32: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc8_35: i32 = int_literal 3
 // CHECK:STDOUT:   %.loc8_36.1: (i32, i32, i32) = tuple_literal (%.loc8_29, %.loc8_32, %.loc8_35)
-// CHECK:STDOUT:   %.loc8_36.2: ref i32 = tuple_access %v, member0
+// CHECK:STDOUT:   %.loc8_36.2: ref i32 = tuple_access %v.var, member0
 // CHECK:STDOUT:   %.loc8_36.3: init i32 = initialize_from %.loc8_29 to %.loc8_36.2
-// CHECK:STDOUT:   %.loc8_36.4: ref i32 = tuple_access %v, member1
+// CHECK:STDOUT:   %.loc8_36.4: ref i32 = tuple_access %v.var, member1
 // CHECK:STDOUT:   %.loc8_36.5: init i32 = initialize_from %.loc8_32 to %.loc8_36.4
-// CHECK:STDOUT:   %.loc8_36.6: ref i32 = tuple_access %v, member2
+// CHECK:STDOUT:   %.loc8_36.6: ref i32 = tuple_access %v.var, member2
 // CHECK:STDOUT:   %.loc8_36.7: init i32 = initialize_from %.loc8_35 to %.loc8_36.6
 // CHECK:STDOUT:   %.loc8_36.8: init (i32, i32, i32) = tuple_init %.loc8_36.1, (%.loc8_36.3, %.loc8_36.5, %.loc8_36.7)
-// CHECK:STDOUT:   assign %v, %.loc8_36.8
+// CHECK:STDOUT:   assign %v.var, %.loc8_36.8
 // CHECK:STDOUT:   %.loc10_24: (type, type, type) = tuple_literal (i32, i32, i32)
 // CHECK:STDOUT:   %v.ref: ref (i32, i32, i32) = name_reference "v", %v
 // CHECK:STDOUT:   %.loc10_28.1: ref i32 = tuple_access %v.ref, member0

toolchain/check/testdata/operators/assignment.carbon

@@ -28,9 +28,10 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %a: ref i32 = var "a"
+// CHECK:STDOUT:   %a.var: ref i32 = var "a"
+// CHECK:STDOUT:   %a: ref i32 = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 12
-// CHECK:STDOUT:   assign %a, %.loc8
+// CHECK:STDOUT:   assign %a.var, %.loc8
 // CHECK:STDOUT:   %a.ref.loc9: ref i32 = name_reference "a", %a
 // CHECK:STDOUT:   %.loc9: i32 = int_literal 9
 // CHECK:STDOUT:   assign %a.ref.loc9, %.loc9
@@ -38,16 +39,17 @@ fn Main() {
 // CHECK:STDOUT:   %.loc11_19.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc11_19.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc11_19.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %b: ref (i32, i32) = var "b"
+// CHECK:STDOUT:   %b.var: ref (i32, i32) = var "b"
+// CHECK:STDOUT:   %b: ref (i32, i32) = bind_name "b", %b.var
 // CHECK:STDOUT:   %.loc11_24: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc11_27: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc11_28.1: (i32, i32) = tuple_literal (%.loc11_24, %.loc11_27)
-// CHECK:STDOUT:   %.loc11_28.2: ref i32 = tuple_access %b, member0
+// CHECK:STDOUT:   %.loc11_28.2: ref i32 = tuple_access %b.var, member0
 // CHECK:STDOUT:   %.loc11_28.3: init i32 = initialize_from %.loc11_24 to %.loc11_28.2
-// CHECK:STDOUT:   %.loc11_28.4: ref i32 = tuple_access %b, member1
+// CHECK:STDOUT:   %.loc11_28.4: ref i32 = tuple_access %b.var, member1
 // CHECK:STDOUT:   %.loc11_28.5: init i32 = initialize_from %.loc11_27 to %.loc11_28.4
 // CHECK:STDOUT:   %.loc11_28.6: init (i32, i32) = tuple_init %.loc11_28.1, (%.loc11_28.3, %.loc11_28.5)
-// CHECK:STDOUT:   assign %b, %.loc11_28.6
+// CHECK:STDOUT:   assign %b.var, %.loc11_28.6
 // CHECK:STDOUT:   %b.ref.loc12: ref (i32, i32) = name_reference "b", %b
 // CHECK:STDOUT:   %.loc12_5: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc12_6: ref i32 = tuple_index %b.ref.loc12, %.loc12_5
@@ -60,16 +62,17 @@ fn Main() {
 // CHECK:STDOUT:   assign %.loc13_6, %.loc13_10
 // CHECK:STDOUT:   %.loc15_27.1: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc15_27.2: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %c: ref {.a: i32, .b: i32} = var "c"
+// CHECK:STDOUT:   %c.var: ref {.a: i32, .b: i32} = var "c"
+// CHECK:STDOUT:   %c: ref {.a: i32, .b: i32} = bind_name "c", %c.var
 // CHECK:STDOUT:   %.loc15_37: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc15_45: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc15_46.1: {.a: i32, .b: i32} = struct_literal (%.loc15_37, %.loc15_45)
-// CHECK:STDOUT:   %.loc15_46.2: ref i32 = struct_access %c, member0
+// CHECK:STDOUT:   %.loc15_46.2: ref i32 = struct_access %c.var, member0
 // CHECK:STDOUT:   %.loc15_46.3: init i32 = initialize_from %.loc15_37 to %.loc15_46.2
-// CHECK:STDOUT:   %.loc15_46.4: ref i32 = struct_access %c, member1
+// CHECK:STDOUT:   %.loc15_46.4: ref i32 = struct_access %c.var, member1
 // CHECK:STDOUT:   %.loc15_46.5: init i32 = initialize_from %.loc15_45 to %.loc15_46.4
 // CHECK:STDOUT:   %.loc15_46.6: init {.a: i32, .b: i32} = struct_init %.loc15_46.1, (%.loc15_46.3, %.loc15_46.5)
-// CHECK:STDOUT:   assign %c, %.loc15_46.6
+// CHECK:STDOUT:   assign %c.var, %.loc15_46.6
 // CHECK:STDOUT:   %c.ref.loc16: ref {.a: i32, .b: i32} = name_reference "c", %c
 // CHECK:STDOUT:   %.loc16_4: ref i32 = struct_access %c.ref.loc16, member0
 // CHECK:STDOUT:   %.loc16_9: i32 = int_literal 3
@@ -79,10 +82,11 @@ fn Main() {
 // CHECK:STDOUT:   %.loc17_9: i32 = int_literal 4
 // CHECK:STDOUT:   assign %.loc17_4, %.loc17_9
 // CHECK:STDOUT:   %.loc19_13: type = ptr_type i32
-// CHECK:STDOUT:   %p: ref i32* = var "p"
+// CHECK:STDOUT:   %p.var: ref i32* = var "p"
+// CHECK:STDOUT:   %p: ref i32* = bind_name "p", %p.var
 // CHECK:STDOUT:   %a.ref.loc19: ref i32 = name_reference "a", %a
 // CHECK:STDOUT:   %.loc19_17: i32* = address_of %a.ref.loc19
-// CHECK:STDOUT:   assign %p, %.loc19_17
+// CHECK:STDOUT:   assign %p.var, %.loc19_17
 // CHECK:STDOUT:   %p.ref.loc20: ref i32* = name_reference "p", %p
 // CHECK:STDOUT:   %.loc20_4: i32* = bind_value %p.ref.loc20
 // CHECK:STDOUT:   %.loc20_3: ref i32 = dereference %.loc20_4

toolchain/check/testdata/operators/fail_assignment_to_non_assignable.carbon

@@ -76,9 +76,10 @@ fn Main() {
 // CHECK:STDOUT:   %.loc21_17.6: init (i32, i32) = tuple_init %.loc21_17.1, (%.loc21_17.3, %.loc21_17.5)
 // CHECK:STDOUT:   assign %.loc21_8.2, %.loc21_17.6
 // CHECK:STDOUT:   %.loc21_8.4: (i32, i32) = tuple_value %.loc21_8.2, (%.loc21_4, %.loc21_7)
-// CHECK:STDOUT:   %n: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var: ref i32 = var "n"
+// CHECK:STDOUT:   %n: ref i32 = bind_name "n", %n.var
 // CHECK:STDOUT:   %.loc22: i32 = int_literal 0
-// CHECK:STDOUT:   assign %n, %.loc22
+// CHECK:STDOUT:   assign %n.var, %.loc22
 // CHECK:STDOUT:   %n.ref.loc26_4: ref i32 = name_reference "n", %n
 // CHECK:STDOUT:   %n.ref.loc26_7: ref i32 = name_reference "n", %n
 // CHECK:STDOUT:   %.loc26_8.1: (i32, i32) = tuple_literal (%n.ref.loc26_4, %n.ref.loc26_7)
@@ -126,7 +127,8 @@ fn Main() {
 // CHECK:STDOUT:   %.loc38_4: i32 = block_arg !if.expr.result.loc38
 // CHECK:STDOUT:   %.loc38_29: i32 = int_literal 3
 // CHECK:STDOUT:   assign %.loc38_4, %.loc38_29
-// CHECK:STDOUT:   %a: ref i32 = var "a"
+// CHECK:STDOUT:   %a.var: ref i32 = var "a"
+// CHECK:STDOUT:   %a: ref i32 = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc45_7: bool = bool_literal true
 // CHECK:STDOUT:   if %.loc45_7 br !if.expr.then.loc45 else br !if.expr.else.loc45
 // CHECK:STDOUT:

toolchain/check/testdata/operators/fail_type_mismatch_assignment.carbon

@@ -18,9 +18,10 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %a: ref i32 = var "a"
+// CHECK:STDOUT:   %a.var: ref i32 = var "a"
+// CHECK:STDOUT:   %a: ref i32 = bind_name "a", %a.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 3
-// CHECK:STDOUT:   assign %a, %.loc8
+// CHECK:STDOUT:   assign %a.var, %.loc8
 // CHECK:STDOUT:   %a.ref: ref i32 = name_reference "a", %a
 // CHECK:STDOUT:   %.loc12: f64 = real_literal 56e-1
 // CHECK:STDOUT:   assign %a.ref, <error>

toolchain/check/testdata/pointer/address_of_deref.carbon

@@ -15,9 +15,10 @@ fn F() -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F() -> i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %n: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var: ref i32 = var "n"
+// CHECK:STDOUT:   %n: ref i32 = bind_name "n", %n.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
-// CHECK:STDOUT:   assign %n, %.loc8
+// CHECK:STDOUT:   assign %n.var, %.loc8
 // CHECK:STDOUT:   %n.ref: ref i32 = name_reference "n", %n
 // CHECK:STDOUT:   %.loc9_13.1: type = ptr_type i32
 // CHECK:STDOUT:   %.loc9_13.2: i32* = address_of %n.ref

toolchain/check/testdata/pointer/address_of_lvalue.carbon

@@ -24,61 +24,68 @@ fn F() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc8_27.1: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc8_27.2: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %s: ref {.a: i32, .b: i32} = var "s"
+// CHECK:STDOUT:   %s.var: ref {.a: i32, .b: i32} = var "s"
+// CHECK:STDOUT:   %s: ref {.a: i32, .b: i32} = bind_name "s", %s.var
 // CHECK:STDOUT:   %.loc8_37: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc8_45: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc8_46.1: {.a: i32, .b: i32} = struct_literal (%.loc8_37, %.loc8_45)
-// CHECK:STDOUT:   %.loc8_46.2: ref i32 = struct_access %s, member0
+// CHECK:STDOUT:   %.loc8_46.2: ref i32 = struct_access %s.var, member0
 // CHECK:STDOUT:   %.loc8_46.3: init i32 = initialize_from %.loc8_37 to %.loc8_46.2
-// CHECK:STDOUT:   %.loc8_46.4: ref i32 = struct_access %s, member1
+// CHECK:STDOUT:   %.loc8_46.4: ref i32 = struct_access %s.var, member1
 // CHECK:STDOUT:   %.loc8_46.5: init i32 = initialize_from %.loc8_45 to %.loc8_46.4
 // CHECK:STDOUT:   %.loc8_46.6: init {.a: i32, .b: i32} = struct_init %.loc8_46.1, (%.loc8_46.3, %.loc8_46.5)
-// CHECK:STDOUT:   assign %s, %.loc8_46.6
+// CHECK:STDOUT:   assign %s.var, %.loc8_46.6
 // CHECK:STDOUT:   %.loc10_27: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc10_28: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %p: ref {.a: i32, .b: i32}* = var "p"
+// CHECK:STDOUT:   %p.var: ref {.a: i32, .b: i32}* = var "p"
+// CHECK:STDOUT:   %p: ref {.a: i32, .b: i32}* = bind_name "p", %p.var
 // CHECK:STDOUT:   %s.ref.loc10: ref {.a: i32, .b: i32} = name_reference "s", %s
 // CHECK:STDOUT:   %.loc10_32: {.a: i32, .b: i32}* = address_of %s.ref.loc10
-// CHECK:STDOUT:   assign %p, %.loc10_32
+// CHECK:STDOUT:   assign %p.var, %.loc10_32
 // CHECK:STDOUT:   %.loc11_13: type = ptr_type i32
-// CHECK:STDOUT:   %q: ref i32* = var "q"
+// CHECK:STDOUT:   %q.var: ref i32* = var "q"
+// CHECK:STDOUT:   %q: ref i32* = bind_name "q", %q.var
 // CHECK:STDOUT:   %s.ref.loc11: ref {.a: i32, .b: i32} = name_reference "s", %s
 // CHECK:STDOUT:   %.loc11_19: ref i32 = struct_access %s.ref.loc11, member0
 // CHECK:STDOUT:   %.loc11_17: i32* = address_of %.loc11_19
-// CHECK:STDOUT:   assign %q, %.loc11_17
+// CHECK:STDOUT:   assign %q.var, %.loc11_17
 // CHECK:STDOUT:   %.loc12_13: type = ptr_type i32
-// CHECK:STDOUT:   %r: ref i32* = var "r"
+// CHECK:STDOUT:   %r.var: ref i32* = var "r"
+// CHECK:STDOUT:   %r: ref i32* = bind_name "r", %r.var
 // CHECK:STDOUT:   %s.ref.loc12: ref {.a: i32, .b: i32} = name_reference "s", %s
 // CHECK:STDOUT:   %.loc12_19: ref i32 = struct_access %s.ref.loc12, member1
 // CHECK:STDOUT:   %.loc12_17: i32* = address_of %.loc12_19
-// CHECK:STDOUT:   assign %r, %.loc12_17
+// CHECK:STDOUT:   assign %r.var, %.loc12_17
 // CHECK:STDOUT:   %.loc14_19.1: type = tuple_type (type, type)
 // CHECK:STDOUT:   %.loc14_19.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc14_19.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc14_19.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %t: ref (i32, i32) = var "t"
+// CHECK:STDOUT:   %t.var: ref (i32, i32) = var "t"
+// CHECK:STDOUT:   %t: ref (i32, i32) = bind_name "t", %t.var
 // CHECK:STDOUT:   %.loc14_24: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc14_27: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc14_28.1: (i32, i32) = tuple_literal (%.loc14_24, %.loc14_27)
-// CHECK:STDOUT:   %.loc14_28.2: ref i32 = tuple_access %t, member0
+// CHECK:STDOUT:   %.loc14_28.2: ref i32 = tuple_access %t.var, member0
 // CHECK:STDOUT:   %.loc14_28.3: init i32 = initialize_from %.loc14_24 to %.loc14_28.2
-// CHECK:STDOUT:   %.loc14_28.4: ref i32 = tuple_access %t, member1
+// CHECK:STDOUT:   %.loc14_28.4: ref i32 = tuple_access %t.var, member1
 // CHECK:STDOUT:   %.loc14_28.5: init i32 = initialize_from %.loc14_27 to %.loc14_28.4
 // CHECK:STDOUT:   %.loc14_28.6: init (i32, i32) = tuple_init %.loc14_28.1, (%.loc14_28.3, %.loc14_28.5)
-// CHECK:STDOUT:   assign %t, %.loc14_28.6
+// CHECK:STDOUT:   assign %t.var, %.loc14_28.6
 // CHECK:STDOUT:   %.loc15_14: type = ptr_type i32
-// CHECK:STDOUT:   %t0: ref i32* = var "t0"
+// CHECK:STDOUT:   %t0.var: ref i32* = var "t0"
+// CHECK:STDOUT:   %t0: ref i32* = bind_name "t0", %t0.var
 // CHECK:STDOUT:   %t.ref.loc15: ref (i32, i32) = name_reference "t", %t
 // CHECK:STDOUT:   %.loc15_21: i32 = int_literal 0
 // CHECK:STDOUT:   %.loc15_22: ref i32 = tuple_index %t.ref.loc15, %.loc15_21
 // CHECK:STDOUT:   %.loc15_18: i32* = address_of %.loc15_22
-// CHECK:STDOUT:   assign %t0, %.loc15_18
+// CHECK:STDOUT:   assign %t0.var, %.loc15_18
 // CHECK:STDOUT:   %.loc16_14: type = ptr_type i32
-// CHECK:STDOUT:   %t1: ref i32* = var "t1"
+// CHECK:STDOUT:   %t1.var: ref i32* = var "t1"
+// CHECK:STDOUT:   %t1: ref i32* = bind_name "t1", %t1.var
 // CHECK:STDOUT:   %t.ref.loc16: ref (i32, i32) = name_reference "t", %t
 // CHECK:STDOUT:   %.loc16_21: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc16_22: ref i32 = tuple_index %t.ref.loc16, %.loc16_21
 // CHECK:STDOUT:   %.loc16_18: i32* = address_of %.loc16_22
-// CHECK:STDOUT:   assign %t1, %.loc16_18
+// CHECK:STDOUT:   assign %t1.var, %.loc16_18
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/pointer/basic.carbon

@@ -17,14 +17,16 @@ fn F() -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @F() -> i32 {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %n: ref i32 = var "n"
+// CHECK:STDOUT:   %n.var: ref i32 = var "n"
+// CHECK:STDOUT:   %n: ref i32 = bind_name "n", %n.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
-// CHECK:STDOUT:   assign %n, %.loc8
+// CHECK:STDOUT:   assign %n.var, %.loc8
 // CHECK:STDOUT:   %.loc9_13: type = ptr_type i32
-// CHECK:STDOUT:   %p: ref i32* = var "p"
+// CHECK:STDOUT:   %p.var: ref i32* = var "p"
+// CHECK:STDOUT:   %p: ref i32* = bind_name "p", %p.var
 // CHECK:STDOUT:   %n.ref: ref i32 = name_reference "n", %n
 // CHECK:STDOUT:   %.loc9_17: i32* = address_of %n.ref
-// CHECK:STDOUT:   assign %p, %.loc9_17
+// CHECK:STDOUT:   assign %p.var, %.loc9_17
 // CHECK:STDOUT:   %p.ref: ref i32* = name_reference "p", %p
 // CHECK:STDOUT:   %.loc11_11: i32* = bind_value %p.ref
 // CHECK:STDOUT:   %.loc11_10.1: ref i32 = dereference %.loc11_11

toolchain/check/testdata/pointer/fail_address_of_value.carbon

@@ -175,9 +175,10 @@ fn AddressOfParameter(param: i32) {
 // CHECK:STDOUT: fn @AddressOfParameter(%param: i32) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc82_22: type = ptr_type i32
-// CHECK:STDOUT:   %param_addr: ref i32* = var "param_addr"
+// CHECK:STDOUT:   %param_addr.var: ref i32* = var "param_addr"
+// CHECK:STDOUT:   %param_addr: ref i32* = bind_name "param_addr", %param_addr.var
 // CHECK:STDOUT:   %param.ref: i32 = name_reference "param", %param
 // CHECK:STDOUT:   %.loc82_26: i32* = address_of %param.ref
-// CHECK:STDOUT:   assign %param_addr, %.loc82_26
+// CHECK:STDOUT:   assign %param_addr.var, %.loc82_26
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/pointer/fail_dereference_type.carbon

@@ -14,5 +14,6 @@ var p: *i32;
 
 // CHECK:STDOUT: file "fail_dereference_type.carbon" {
 // CHECK:STDOUT:   %.loc13: ref <error> = dereference i32
-// CHECK:STDOUT:   %p: ref <error> = var "p"
+// CHECK:STDOUT:   %p.var: ref <error> = var "p"
+// CHECK:STDOUT:   %p: ref <error> = bind_name "p", %p.var
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/empty.carbon

@@ -11,13 +11,15 @@ var y: {} = x;
 // CHECK:STDOUT:   %.loc7_9.1: type = struct_type {}
 // CHECK:STDOUT:   %.loc7_9.2: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc7_9.3: type = tuple_type ()
-// CHECK:STDOUT:   %x: ref {} = var "x"
+// CHECK:STDOUT:   %x.var: ref {} = var "x"
+// CHECK:STDOUT:   %x: ref {} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_14.1: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc7_14.2: init {} = struct_init %.loc7_14.1, ()
-// CHECK:STDOUT:   assign %x, %.loc7_14.2
+// CHECK:STDOUT:   assign %x.var, %.loc7_14.2
 // CHECK:STDOUT:   %.loc8_9: {} = struct_literal ()
-// CHECK:STDOUT:   %y: ref {} = var "y"
+// CHECK:STDOUT:   %y.var: ref {} = var "y"
+// CHECK:STDOUT:   %y: ref {} = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {} = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_13: init {} = struct_init %x.ref, ()
-// CHECK:STDOUT:   assign %y, %.loc8_13
+// CHECK:STDOUT:   assign %y.var, %.loc8_13
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_assign_empty.carbon

@@ -11,8 +11,9 @@ var x: {.a: i32} = {};
 
 // CHECK:STDOUT: file "fail_assign_empty.carbon" {
 // CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_21.1: type = struct_type {}
 // CHECK:STDOUT:   %.loc10_21.2: {} = struct_literal ()
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_assign_nested.carbon

@@ -15,9 +15,10 @@ var x: {.a: {}} = {.b = {}};
 // CHECK:STDOUT:   %.loc10_15.1: type = struct_type {.a: {}}
 // CHECK:STDOUT:   %.loc10_14.3: type = tuple_type ()
 // CHECK:STDOUT:   %.loc10_15.2: type = struct_type {.a: ()}
-// CHECK:STDOUT:   %x: ref {.a: {}} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: {}} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: {}} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_26: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc10_27.1: type = struct_type {.b: {}}
 // CHECK:STDOUT:   %.loc10_27.2: {.b: {}} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_assign_to_empty.carbon

@@ -13,9 +13,10 @@ var x: {} = {.a = 1};
 // CHECK:STDOUT:   %.loc10_9.1: type = struct_type {}
 // CHECK:STDOUT:   %.loc10_9.2: {} = struct_literal ()
 // CHECK:STDOUT:   %.loc10_9.3: type = tuple_type ()
-// CHECK:STDOUT:   %x: ref {} = var "x"
+// CHECK:STDOUT:   %x.var: ref {} = var "x"
+// CHECK:STDOUT:   %x: ref {} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_19: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_20.1: type = struct_type {.a: i32}
 // CHECK:STDOUT:   %.loc10_20.2: {.a: i32} = struct_literal (%.loc10_19)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_field_name_mismatch.carbon

@@ -11,9 +11,10 @@ var x: {.a: i32} = {.b = 1};
 
 // CHECK:STDOUT: file "fail_field_name_mismatch.carbon" {
 // CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_26: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_27.1: type = struct_type {.b: i32}
 // CHECK:STDOUT:   %.loc10_27.2: {.b: i32} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_field_type_mismatch.carbon

@@ -11,9 +11,10 @@ var x: {.a: i32} = {.b = 1.0};
 
 // CHECK:STDOUT: file "fail_field_type_mismatch.carbon" {
 // CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_26: f64 = real_literal 10e-1
 // CHECK:STDOUT:   %.loc10_29.1: type = struct_type {.b: f64}
 // CHECK:STDOUT:   %.loc10_29.2: {.b: f64} = struct_literal (%.loc10_26)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_member_access_type.carbon

@@ -12,12 +12,14 @@ var y: i32 = x.b;
 
 // CHECK:STDOUT: file "fail_member_access_type.carbon" {
 // CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: f64}
-// CHECK:STDOUT:   %x: ref {.a: f64} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: f64} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: f64} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_26: f64 = real_literal 40e-1
 // CHECK:STDOUT:   %.loc7_29.1: {.a: f64} = struct_literal (%.loc7_26)
 // CHECK:STDOUT:   %.loc7_29.2: init {.a: f64} = struct_init %.loc7_29.1, (%.loc7_26)
-// CHECK:STDOUT:   assign %x, %.loc7_29.2
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   assign %x.var, %.loc7_29.2
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: f64} = name_reference "x", %x
-// CHECK:STDOUT:   assign %y, <error>
+// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_nested_incomplete.carbon

@@ -24,14 +24,16 @@ var p: Incomplete* = &s.a;
 // CHECK:STDOUT:   %Incomplete: type = class_type @Incomplete
 // CHECK:STDOUT:   %Incomplete.ref.loc15: type = name_reference "Incomplete", %Incomplete
 // CHECK:STDOUT:   %.loc15: type = struct_type {.a: Incomplete}
-// CHECK:STDOUT:   %s: ref <error> = var "s"
+// CHECK:STDOUT:   %s.var: ref <error> = var "s"
+// CHECK:STDOUT:   %s: ref <error> = bind_name "s", %s.var
 // CHECK:STDOUT:   %Incomplete.ref.loc20: type = name_reference "Incomplete", %Incomplete
 // CHECK:STDOUT:   %.loc20_18: type = ptr_type Incomplete
-// CHECK:STDOUT:   %p: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p.var: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p: ref Incomplete* = bind_name "p", %p.var
 // CHECK:STDOUT:   %s.ref: ref <error> = name_reference "s", %s
 // CHECK:STDOUT:   %.loc20_22.1: type = ptr_type <error>
 // CHECK:STDOUT:   %.loc20_22.2: <error>* = address_of <error>
-// CHECK:STDOUT:   assign %p, <error>
+// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;

toolchain/check/testdata/struct/fail_non_member_access.carbon

@@ -12,12 +12,14 @@ var y: i32 = x.b;
 
 // CHECK:STDOUT: file "fail_non_member_access.carbon" {
 // CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 4
 // CHECK:STDOUT:   %.loc7_27.1: {.a: i32} = struct_literal (%.loc7_26)
 // CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init %.loc7_27.1, (%.loc7_26)
-// CHECK:STDOUT:   assign %x, %.loc7_27.2
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   assign %x.var, %.loc7_27.2
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_reference "x", %x
-// CHECK:STDOUT:   assign %y, <error>
+// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_too_few_values.carbon

@@ -12,9 +12,10 @@ var x: {.a: i32, .b: i32} = {.a = 1};
 // CHECK:STDOUT: file "fail_too_few_values.carbon" {
 // CHECK:STDOUT:   %.loc10_25.1: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc10_25.2: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32, .b: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_35: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_36.1: type = struct_type {.a: i32}
 // CHECK:STDOUT:   %.loc10_36.2: {.a: i32} = struct_literal (%.loc10_35)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_type_assign.carbon

@@ -11,7 +11,8 @@ var x: {.a: i32} = {.a: i32};
 
 // CHECK:STDOUT: file "fail_type_assign.carbon" {
 // CHECK:STDOUT:   %.loc10_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_28: type = struct_type {.a: i32}
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/fail_value_as_type.carbon

@@ -13,5 +13,6 @@ var x: {.a = 1};
 // CHECK:STDOUT:   %.loc10_14: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_15.1: type = struct_type {.a: i32}
 // CHECK:STDOUT:   %.loc10_15.2: {.a: i32} = struct_literal (%.loc10_14)
-// CHECK:STDOUT:   %x: ref <error> = var "x"
+// CHECK:STDOUT:   %x.var: ref <error> = var "x"
+// CHECK:STDOUT:   %x: ref <error> = bind_name "x", %x.var
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/member_access.carbon

@@ -11,23 +11,26 @@ var z: i32 = y;
 // CHECK:STDOUT: file "member_access.carbon" {
 // CHECK:STDOUT:   %.loc7_25.1: type = struct_type {.a: f64, .b: i32}
 // CHECK:STDOUT:   %.loc7_25.2: type = ptr_type {.a: f64, .b: i32}
-// CHECK:STDOUT:   %x: ref {.a: f64, .b: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: f64, .b: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: f64, .b: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_35: f64 = real_literal 0e-1
 // CHECK:STDOUT:   %.loc7_45: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_46.1: {.a: f64, .b: i32} = struct_literal (%.loc7_35, %.loc7_45)
-// CHECK:STDOUT:   %.loc7_46.2: ref f64 = struct_access %x, member0
+// CHECK:STDOUT:   %.loc7_46.2: ref f64 = struct_access %x.var, member0
 // CHECK:STDOUT:   %.loc7_46.3: init f64 = initialize_from %.loc7_35 to %.loc7_46.2
-// CHECK:STDOUT:   %.loc7_46.4: ref i32 = struct_access %x, member1
+// CHECK:STDOUT:   %.loc7_46.4: ref i32 = struct_access %x.var, member1
 // CHECK:STDOUT:   %.loc7_46.5: init i32 = initialize_from %.loc7_45 to %.loc7_46.4
 // CHECK:STDOUT:   %.loc7_46.6: init {.a: f64, .b: i32} = struct_init %.loc7_46.1, (%.loc7_46.3, %.loc7_46.5)
-// CHECK:STDOUT:   assign %x, %.loc7_46.6
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   assign %x.var, %.loc7_46.6
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: f64, .b: i32} = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_15.1: ref i32 = struct_access %x.ref, member1
 // CHECK:STDOUT:   %.loc8_15.2: i32 = bind_value %.loc8_15.1
-// CHECK:STDOUT:   assign %y, %.loc8_15.2
-// CHECK:STDOUT:   %z: ref i32 = var "z"
+// CHECK:STDOUT:   assign %y.var, %.loc8_15.2
+// CHECK:STDOUT:   %z.var: ref i32 = var "z"
+// CHECK:STDOUT:   %z: ref i32 = bind_name "z", %z.var
 // CHECK:STDOUT:   %y.ref: ref i32 = name_reference "y", %y
 // CHECK:STDOUT:   %.loc9: i32 = bind_value %y.ref
-// CHECK:STDOUT:   assign %z, %.loc9
+// CHECK:STDOUT:   assign %z.var, %.loc9
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/nested_struct_in_place.carbon

@@ -25,15 +25,16 @@ fn G() {
 // CHECK:STDOUT:   %.loc10_51.1: type = struct_type {.a: (i32, i32, i32), .b: (i32, i32, i32)}
 // CHECK:STDOUT:   %.loc10_51.2: type = struct_type {.a: (i32, i32, i32)*, .b: (i32, i32, i32)*}
 // CHECK:STDOUT:   %.loc10_51.3: type = ptr_type {.a: (i32, i32, i32)*, .b: (i32, i32, i32)*}
-// CHECK:STDOUT:   %v: ref {.a: (i32, i32, i32), .b: (i32, i32, i32)} = var "v"
+// CHECK:STDOUT:   %v.var: ref {.a: (i32, i32, i32), .b: (i32, i32, i32)} = var "v"
+// CHECK:STDOUT:   %v: ref {.a: (i32, i32, i32), .b: (i32, i32, i32)} = bind_name "v", %v.var
 // CHECK:STDOUT:   %F.ref.loc10_61: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc10_74.1: ref (i32, i32, i32) = struct_access %v, member0
+// CHECK:STDOUT:   %.loc10_74.1: ref (i32, i32, i32) = struct_access %v.var, member0
 // CHECK:STDOUT:   %.loc10_62: init (i32, i32, i32) = call %F.ref.loc10_61() to %.loc10_74.1
 // CHECK:STDOUT:   %F.ref.loc10_71: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc10_74.2: ref (i32, i32, i32) = struct_access %v, member1
+// CHECK:STDOUT:   %.loc10_74.2: ref (i32, i32, i32) = struct_access %v.var, member1
 // CHECK:STDOUT:   %.loc10_72: init (i32, i32, i32) = call %F.ref.loc10_71() to %.loc10_74.2
 // CHECK:STDOUT:   %.loc10_74.3: {.a: (i32, i32, i32), .b: (i32, i32, i32)} = struct_literal (%.loc10_62, %.loc10_72)
 // CHECK:STDOUT:   %.loc10_74.4: init {.a: (i32, i32, i32), .b: (i32, i32, i32)} = struct_init %.loc10_74.3, (%.loc10_62, %.loc10_72)
-// CHECK:STDOUT:   assign %v, %.loc10_74.4
+// CHECK:STDOUT:   assign %v.var, %.loc10_74.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/one_entry.carbon

@@ -9,16 +9,18 @@ var y: {.a: i32} = x;
 
 // CHECK:STDOUT: file "one_entry.carbon" {
 // CHECK:STDOUT:   %.loc7_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_26: i32 = int_literal 4
 // CHECK:STDOUT:   %.loc7_27.1: {.a: i32} = struct_literal (%.loc7_26)
 // CHECK:STDOUT:   %.loc7_27.2: init {.a: i32} = struct_init %.loc7_27.1, (%.loc7_26)
-// CHECK:STDOUT:   assign %x, %.loc7_27.2
+// CHECK:STDOUT:   assign %x.var, %.loc7_27.2
 // CHECK:STDOUT:   %.loc8_16: type = struct_type {.a: i32}
-// CHECK:STDOUT:   %y: ref {.a: i32} = var "y"
+// CHECK:STDOUT:   %y.var: ref {.a: i32} = var "y"
+// CHECK:STDOUT:   %y: ref {.a: i32} = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: i32} = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_20.1: ref i32 = struct_access %x.ref, member0
 // CHECK:STDOUT:   %.loc8_20.2: i32 = bind_value %.loc8_20.1
 // CHECK:STDOUT:   %.loc8_20.3: init {.a: i32} = struct_init %x.ref, (%.loc8_20.2)
-// CHECK:STDOUT:   assign %y, %.loc8_20.3
+// CHECK:STDOUT:   assign %y.var, %.loc8_20.3
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/tuple_as_element.carbon

@@ -13,32 +13,34 @@ var y: {.a: i32, .b: (i32,)} = x;
 // CHECK:STDOUT:   %.loc7_27.3: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc7_28.1: type = struct_type {.a: i32, .b: (i32,)}
 // CHECK:STDOUT:   %.loc7_28.2: type = ptr_type {.a: i32, .b: (i32,)}
-// CHECK:STDOUT:   %x: ref {.a: i32, .b: (i32,)} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32, .b: (i32,)} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32, .b: (i32,)} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_38: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_47: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_49.1: (i32,) = tuple_literal (%.loc7_47)
 // CHECK:STDOUT:   %.loc7_50.1: {.a: i32, .b: (i32,)} = struct_literal (%.loc7_38, %.loc7_49.1)
-// CHECK:STDOUT:   %.loc7_50.2: ref i32 = struct_access %x, member0
+// CHECK:STDOUT:   %.loc7_50.2: ref i32 = struct_access %x.var, member0
 // CHECK:STDOUT:   %.loc7_50.3: init i32 = initialize_from %.loc7_38 to %.loc7_50.2
 // CHECK:STDOUT:   %.loc7_49.2: init (i32,) = tuple_init %.loc7_49.1, (%.loc7_47)
-// CHECK:STDOUT:   %.loc7_50.4: ref (i32,) = struct_access %x, member1
+// CHECK:STDOUT:   %.loc7_50.4: ref (i32,) = struct_access %x.var, member1
 // CHECK:STDOUT:   %.loc7_50.5: init (i32,) = initialize_from %.loc7_49.2 to %.loc7_50.4
 // CHECK:STDOUT:   %.loc7_50.6: init {.a: i32, .b: (i32,)} = struct_init %.loc7_50.1, (%.loc7_50.3, %.loc7_50.5)
-// CHECK:STDOUT:   assign %x, %.loc7_50.6
+// CHECK:STDOUT:   assign %x.var, %.loc7_50.6
 // CHECK:STDOUT:   %.loc8_27: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc8_28: type = struct_type {.a: i32, .b: (i32,)}
-// CHECK:STDOUT:   %y: ref {.a: i32, .b: (i32,)} = var "y"
+// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: (i32,)} = var "y"
+// CHECK:STDOUT:   %y: ref {.a: i32, .b: (i32,)} = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: (i32,)} = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_32.1: ref i32 = struct_access %x.ref, member0
 // CHECK:STDOUT:   %.loc8_32.2: i32 = bind_value %.loc8_32.1
-// CHECK:STDOUT:   %.loc8_32.3: ref i32 = struct_access %y, member0
+// CHECK:STDOUT:   %.loc8_32.3: ref i32 = struct_access %y.var, member0
 // CHECK:STDOUT:   %.loc8_32.4: init i32 = initialize_from %.loc8_32.2 to %.loc8_32.3
 // CHECK:STDOUT:   %.loc8_32.5: ref (i32,) = struct_access %x.ref, member1
 // CHECK:STDOUT:   %.loc8_32.6: ref i32 = tuple_access %.loc8_32.5, member0
 // CHECK:STDOUT:   %.loc8_32.7: i32 = bind_value %.loc8_32.6
 // CHECK:STDOUT:   %.loc8_32.8: init (i32,) = tuple_init %.loc8_32.5, (%.loc8_32.7)
-// CHECK:STDOUT:   %.loc8_32.9: ref (i32,) = struct_access %y, member1
+// CHECK:STDOUT:   %.loc8_32.9: ref (i32,) = struct_access %y.var, member1
 // CHECK:STDOUT:   %.loc8_32.10: init (i32,) = initialize_from %.loc8_32.8 to %.loc8_32.9
 // CHECK:STDOUT:   %.loc8_32.11: init {.a: i32, .b: (i32,)} = struct_init %x.ref, (%.loc8_32.4, %.loc8_32.10)
-// CHECK:STDOUT:   assign %y, %.loc8_32.11
+// CHECK:STDOUT:   assign %y.var, %.loc8_32.11
 // CHECK:STDOUT: }

toolchain/check/testdata/struct/two_entries.carbon

@@ -10,27 +10,29 @@ var y: {.a: i32, .b: i32} = x;
 // CHECK:STDOUT: file "two_entries.carbon" {
 // CHECK:STDOUT:   %.loc7_25.1: type = struct_type {.a: i32, .b: i32}
 // CHECK:STDOUT:   %.loc7_25.2: type = ptr_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = var "x"
+// CHECK:STDOUT:   %x.var: ref {.a: i32, .b: i32} = var "x"
+// CHECK:STDOUT:   %x: ref {.a: i32, .b: i32} = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_35: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc7_43: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc7_44.1: {.a: i32, .b: i32} = struct_literal (%.loc7_35, %.loc7_43)
-// CHECK:STDOUT:   %.loc7_44.2: ref i32 = struct_access %x, member0
+// CHECK:STDOUT:   %.loc7_44.2: ref i32 = struct_access %x.var, member0
 // CHECK:STDOUT:   %.loc7_44.3: init i32 = initialize_from %.loc7_35 to %.loc7_44.2
-// CHECK:STDOUT:   %.loc7_44.4: ref i32 = struct_access %x, member1
+// CHECK:STDOUT:   %.loc7_44.4: ref i32 = struct_access %x.var, member1
 // CHECK:STDOUT:   %.loc7_44.5: init i32 = initialize_from %.loc7_43 to %.loc7_44.4
 // CHECK:STDOUT:   %.loc7_44.6: init {.a: i32, .b: i32} = struct_init %.loc7_44.1, (%.loc7_44.3, %.loc7_44.5)
-// CHECK:STDOUT:   assign %x, %.loc7_44.6
+// CHECK:STDOUT:   assign %x.var, %.loc7_44.6
 // CHECK:STDOUT:   %.loc8_25: type = struct_type {.a: i32, .b: i32}
-// CHECK:STDOUT:   %y: ref {.a: i32, .b: i32} = var "y"
+// CHECK:STDOUT:   %y.var: ref {.a: i32, .b: i32} = var "y"
+// CHECK:STDOUT:   %y: ref {.a: i32, .b: i32} = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref {.a: i32, .b: i32} = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_29.1: ref i32 = struct_access %x.ref, member0
 // CHECK:STDOUT:   %.loc8_29.2: i32 = bind_value %.loc8_29.1
-// CHECK:STDOUT:   %.loc8_29.3: ref i32 = struct_access %y, member0
+// CHECK:STDOUT:   %.loc8_29.3: ref i32 = struct_access %y.var, member0
 // CHECK:STDOUT:   %.loc8_29.4: init i32 = initialize_from %.loc8_29.2 to %.loc8_29.3
 // CHECK:STDOUT:   %.loc8_29.5: ref i32 = struct_access %x.ref, member1
 // CHECK:STDOUT:   %.loc8_29.6: i32 = bind_value %.loc8_29.5
-// CHECK:STDOUT:   %.loc8_29.7: ref i32 = struct_access %y, member1
+// CHECK:STDOUT:   %.loc8_29.7: ref i32 = struct_access %y.var, member1
 // CHECK:STDOUT:   %.loc8_29.8: init i32 = initialize_from %.loc8_29.6 to %.loc8_29.7
 // CHECK:STDOUT:   %.loc8_29.9: init {.a: i32, .b: i32} = struct_init %x.ref, (%.loc8_29.4, %.loc8_29.8)
-// CHECK:STDOUT:   assign %y, %.loc8_29.9
+// CHECK:STDOUT:   assign %y.var, %.loc8_29.9
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/empty.carbon

@@ -10,13 +10,15 @@ var y: () = x;
 // CHECK:STDOUT: file "empty.carbon" {
 // CHECK:STDOUT:   %.loc7_9.1: type = tuple_type ()
 // CHECK:STDOUT:   %.loc7_9.2: () = tuple_literal ()
-// CHECK:STDOUT:   %x: ref () = var "x"
+// CHECK:STDOUT:   %x.var: ref () = var "x"
+// CHECK:STDOUT:   %x: ref () = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_14.1: () = tuple_literal ()
 // CHECK:STDOUT:   %.loc7_14.2: init () = tuple_init %.loc7_14.1, ()
-// CHECK:STDOUT:   assign %x, %.loc7_14.2
+// CHECK:STDOUT:   assign %x.var, %.loc7_14.2
 // CHECK:STDOUT:   %.loc8_9: () = tuple_literal ()
-// CHECK:STDOUT:   %y: ref () = var "y"
+// CHECK:STDOUT:   %y.var: ref () = var "y"
+// CHECK:STDOUT:   %y: ref () = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref () = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_13: init () = tuple_init %x.ref, ()
-// CHECK:STDOUT:   assign %y, %.loc8_13
+// CHECK:STDOUT:   assign %y.var, %.loc8_13
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_assign_empty.carbon

@@ -13,8 +13,9 @@ var x: (i32,) = ();
 // CHECK:STDOUT:   %.loc10_13.1: type = tuple_type (type)
 // CHECK:STDOUT:   %.loc10_13.2: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc10_13.3: type = tuple_type (i32)
-// CHECK:STDOUT:   %x: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x: ref (i32,) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_18.1: type = tuple_type ()
 // CHECK:STDOUT:   %.loc10_18.2: () = tuple_literal ()
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_assign_nested.carbon

@@ -20,7 +20,8 @@ var x: ((i32, i32), (i32, i32)) = ((1, 2, 3), (4, 5, 6));
 // CHECK:STDOUT:   %.loc10_31.5: type = ptr_type (i32, i32)
 // CHECK:STDOUT:   %.loc10_31.6: type = tuple_type ((i32, i32)*, (i32, i32)*)
 // CHECK:STDOUT:   %.loc10_31.7: type = ptr_type ((i32, i32)*, (i32, i32)*)
-// CHECK:STDOUT:   %x: ref ((i32, i32), (i32, i32)) = var "x"
+// CHECK:STDOUT:   %x.var: ref ((i32, i32), (i32, i32)) = var "x"
+// CHECK:STDOUT:   %x: ref ((i32, i32), (i32, i32)) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_37: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc10_40: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_43: i32 = int_literal 3
@@ -32,5 +33,5 @@ var x: ((i32, i32), (i32, i32)) = ((1, 2, 3), (4, 5, 6));
 // CHECK:STDOUT:   %.loc10_55: (i32, i32, i32) = tuple_literal (%.loc10_48, %.loc10_51, %.loc10_54)
 // CHECK:STDOUT:   %.loc10_56.1: type = tuple_type ((i32, i32, i32), (i32, i32, i32))
 // CHECK:STDOUT:   %.loc10_56.2: ((i32, i32, i32), (i32, i32, i32)) = tuple_literal (%.loc10_44.2, %.loc10_55)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_assign_to_empty.carbon

@@ -12,7 +12,8 @@ var x: () = (66);
 // CHECK:STDOUT: file "fail_assign_to_empty.carbon" {
 // CHECK:STDOUT:   %.loc10_9.1: type = tuple_type ()
 // CHECK:STDOUT:   %.loc10_9.2: () = tuple_literal ()
-// CHECK:STDOUT:   %x: ref () = var "x"
+// CHECK:STDOUT:   %x.var: ref () = var "x"
+// CHECK:STDOUT:   %x: ref () = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_14: i32 = int_literal 66
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_element_type_mismatch.carbon

@@ -14,12 +14,13 @@ var x: (i32, i32) = (2, 65.89);
 // CHECK:STDOUT:   %.loc10_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc10_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc10_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %x: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x: ref (i32, i32) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_25: f64 = real_literal 6589e-2
 // CHECK:STDOUT:   %.loc10_30.1: type = tuple_type (i32, f64)
 // CHECK:STDOUT:   %.loc10_30.2: (i32, f64) = tuple_literal (%.loc10_22, %.loc10_25)
-// CHECK:STDOUT:   %.loc10_30.3: ref i32 = tuple_access %x, member0
+// CHECK:STDOUT:   %.loc10_30.3: ref i32 = tuple_access %x.var, member0
 // CHECK:STDOUT:   %.loc10_30.4: init i32 = initialize_from %.loc10_22 to %.loc10_30.3
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_nested_incomplete.carbon

@@ -26,15 +26,17 @@ var p: Incomplete* = &t[1];
 // CHECK:STDOUT:   %.loc15_24.1: type = tuple_type (type, type)
 // CHECK:STDOUT:   %.loc15_24.2: (type, type) = tuple_literal (i32, %Incomplete.ref.loc15)
 // CHECK:STDOUT:   %.loc15_24.3: type = tuple_type (i32, Incomplete)
-// CHECK:STDOUT:   %t: ref <error> = var "t"
+// CHECK:STDOUT:   %t.var: ref <error> = var "t"
+// CHECK:STDOUT:   %t: ref <error> = bind_name "t", %t.var
 // CHECK:STDOUT:   %Incomplete.ref.loc20: type = name_reference "Incomplete", %Incomplete
 // CHECK:STDOUT:   %.loc20_18: type = ptr_type Incomplete
-// CHECK:STDOUT:   %p: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p.var: ref Incomplete* = var "p"
+// CHECK:STDOUT:   %p: ref Incomplete* = bind_name "p", %p.var
 // CHECK:STDOUT:   %t.ref: ref <error> = name_reference "t", %t
 // CHECK:STDOUT:   %.loc20_25: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc20_22.1: type = ptr_type <error>
 // CHECK:STDOUT:   %.loc20_22.2: <error>* = address_of <error>
-// CHECK:STDOUT:   assign %p, <error>
+// CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Incomplete;

toolchain/check/testdata/tuples/fail_too_few_element.carbon

@@ -14,9 +14,10 @@ var x: (i32, i32) = (2, );
 // CHECK:STDOUT:   %.loc10_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc10_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc10_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %x: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x: ref (i32, i32) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_22: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc10_25.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc10_25.2: (i32,) = tuple_literal (%.loc10_22)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_type_assign.carbon

@@ -13,7 +13,8 @@ var x: (i32, ) = (i32, );
 // CHECK:STDOUT:   %.loc10_14.1: type = tuple_type (type)
 // CHECK:STDOUT:   %.loc10_14.2: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc10_14.3: type = tuple_type (i32)
-// CHECK:STDOUT:   %x: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x: ref (i32,) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc10_24: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/fail_value_as_type.carbon

@@ -14,5 +14,6 @@ var x: (1, );
 // CHECK:STDOUT:   %.loc10_12.1: type = tuple_type (i32)
 // CHECK:STDOUT:   %.loc10_12.2: (i32,) = tuple_literal (%.loc10_9)
 // CHECK:STDOUT:   %.loc10_12.3: type = tuple_type (<error>)
-// CHECK:STDOUT:   %x: ref (<error>,) = var "x"
+// CHECK:STDOUT:   %x.var: ref (<error>,) = var "x"
+// CHECK:STDOUT:   %x: ref (<error>,) = bind_name "x", %x.var
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/nested_tuple.carbon

@@ -16,20 +16,21 @@ var x: ((i32, i32), i32) = ((12, 76), 6);
 // CHECK:STDOUT:   %.loc7_24.5: type = ptr_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_24.6: type = tuple_type ((i32, i32)*, i32)
 // CHECK:STDOUT:   %.loc7_24.7: type = ptr_type ((i32, i32)*, i32)
-// CHECK:STDOUT:   %x: ref ((i32, i32), i32) = var "x"
+// CHECK:STDOUT:   %x.var: ref ((i32, i32), i32) = var "x"
+// CHECK:STDOUT:   %x: ref ((i32, i32), i32) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_30: i32 = int_literal 12
 // CHECK:STDOUT:   %.loc7_34: i32 = int_literal 76
 // CHECK:STDOUT:   %.loc7_36.1: (i32, i32) = tuple_literal (%.loc7_30, %.loc7_34)
 // CHECK:STDOUT:   %.loc7_39: i32 = int_literal 6
 // CHECK:STDOUT:   %.loc7_40.1: ((i32, i32), i32) = tuple_literal (%.loc7_36.1, %.loc7_39)
-// CHECK:STDOUT:   %.loc7_40.2: ref (i32, i32) = tuple_access %x, member0
+// CHECK:STDOUT:   %.loc7_40.2: ref (i32, i32) = tuple_access %x.var, member0
 // CHECK:STDOUT:   %.loc7_36.2: ref i32 = tuple_access %.loc7_40.2, member0
 // CHECK:STDOUT:   %.loc7_36.3: init i32 = initialize_from %.loc7_30 to %.loc7_36.2
 // CHECK:STDOUT:   %.loc7_36.4: ref i32 = tuple_access %.loc7_40.2, member1
 // CHECK:STDOUT:   %.loc7_36.5: init i32 = initialize_from %.loc7_34 to %.loc7_36.4
 // CHECK:STDOUT:   %.loc7_36.6: init (i32, i32) = tuple_init %.loc7_36.1, (%.loc7_36.3, %.loc7_36.5)
-// CHECK:STDOUT:   %.loc7_40.3: ref i32 = tuple_access %x, member1
+// CHECK:STDOUT:   %.loc7_40.3: ref i32 = tuple_access %x.var, member1
 // CHECK:STDOUT:   %.loc7_40.4: init i32 = initialize_from %.loc7_39 to %.loc7_40.3
 // CHECK:STDOUT:   %.loc7_40.5: init ((i32, i32), i32) = tuple_init %.loc7_40.1, (%.loc7_36.6, %.loc7_40.4)
-// CHECK:STDOUT:   assign %x, %.loc7_40.5
+// CHECK:STDOUT:   assign %x.var, %.loc7_40.5
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/nested_tuple_in_place.carbon

@@ -32,16 +32,17 @@ fn H() {
 // CHECK:STDOUT:   %.loc10_43.3: type = tuple_type ((i32, i32, i32), (i32, i32, i32))
 // CHECK:STDOUT:   %.loc10_43.4: type = tuple_type ((i32, i32, i32)*, (i32, i32, i32)*)
 // CHECK:STDOUT:   %.loc10_43.5: type = ptr_type ((i32, i32, i32)*, (i32, i32, i32)*)
-// CHECK:STDOUT:   %v: ref ((i32, i32, i32), (i32, i32, i32)) = var "v"
+// CHECK:STDOUT:   %v.var: ref ((i32, i32, i32), (i32, i32, i32)) = var "v"
+// CHECK:STDOUT:   %v: ref ((i32, i32, i32), (i32, i32, i32)) = bind_name "v", %v.var
 // CHECK:STDOUT:   %F.ref.loc10_48: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc10_56.1: ref (i32, i32, i32) = tuple_access %v, member0
+// CHECK:STDOUT:   %.loc10_56.1: ref (i32, i32, i32) = tuple_access %v.var, member0
 // CHECK:STDOUT:   %.loc10_49: init (i32, i32, i32) = call %F.ref.loc10_48() to %.loc10_56.1
 // CHECK:STDOUT:   %F.ref.loc10_53: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc10_56.2: ref (i32, i32, i32) = tuple_access %v, member1
+// CHECK:STDOUT:   %.loc10_56.2: ref (i32, i32, i32) = tuple_access %v.var, member1
 // CHECK:STDOUT:   %.loc10_54: init (i32, i32, i32) = call %F.ref.loc10_53() to %.loc10_56.2
 // CHECK:STDOUT:   %.loc10_56.3: ((i32, i32, i32), (i32, i32, i32)) = tuple_literal (%.loc10_49, %.loc10_54)
 // CHECK:STDOUT:   %.loc10_56.4: init ((i32, i32, i32), (i32, i32, i32)) = tuple_init %.loc10_56.3, (%.loc10_49, %.loc10_54)
-// CHECK:STDOUT:   assign %v, %.loc10_56.4
+// CHECK:STDOUT:   assign %v.var, %.loc10_56.4
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -53,18 +54,19 @@ fn H() {
 // CHECK:STDOUT:   %.loc14_36.3: type = tuple_type (i32, (i32, i32, i32), i32)
 // CHECK:STDOUT:   %.loc14_36.4: type = tuple_type (i32, (i32, i32, i32)*, i32)
 // CHECK:STDOUT:   %.loc14_36.5: type = ptr_type (i32, (i32, i32, i32)*, i32)
-// CHECK:STDOUT:   %v: ref (i32, (i32, i32, i32), i32) = var "v"
+// CHECK:STDOUT:   %v.var: ref (i32, (i32, i32, i32), i32) = var "v"
+// CHECK:STDOUT:   %v: ref (i32, (i32, i32, i32), i32) = bind_name "v", %v.var
 // CHECK:STDOUT:   %.loc14_41: i32 = int_literal 1
 // CHECK:STDOUT:   %F.ref: <function> = name_reference "F", file.%F
-// CHECK:STDOUT:   %.loc14_50.1: ref (i32, i32, i32) = tuple_access %v, member1
+// CHECK:STDOUT:   %.loc14_50.1: ref (i32, i32, i32) = tuple_access %v.var, member1
 // CHECK:STDOUT:   %.loc14_45: init (i32, i32, i32) = call %F.ref() to %.loc14_50.1
 // CHECK:STDOUT:   %.loc14_49: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc14_50.2: (i32, (i32, i32, i32), i32) = tuple_literal (%.loc14_41, %.loc14_45, %.loc14_49)
-// CHECK:STDOUT:   %.loc14_50.3: ref i32 = tuple_access %v, member0
+// CHECK:STDOUT:   %.loc14_50.3: ref i32 = tuple_access %v.var, member0
 // CHECK:STDOUT:   %.loc14_50.4: init i32 = initialize_from %.loc14_41 to %.loc14_50.3
-// CHECK:STDOUT:   %.loc14_50.5: ref i32 = tuple_access %v, member2
+// CHECK:STDOUT:   %.loc14_50.5: ref i32 = tuple_access %v.var, member2
 // CHECK:STDOUT:   %.loc14_50.6: init i32 = initialize_from %.loc14_49 to %.loc14_50.5
 // CHECK:STDOUT:   %.loc14_50.7: init (i32, (i32, i32, i32), i32) = tuple_init %.loc14_50.2, (%.loc14_50.4, %.loc14_45, %.loc14_50.6)
-// CHECK:STDOUT:   assign %v, %.loc14_50.7
+// CHECK:STDOUT:   assign %v.var, %.loc14_50.7
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/one_element.carbon

@@ -11,16 +11,18 @@ var y: (i32,) = x;
 // CHECK:STDOUT:   %.loc7_13.1: type = tuple_type (type)
 // CHECK:STDOUT:   %.loc7_13.2: (type,) = tuple_literal (i32)
 // CHECK:STDOUT:   %.loc7_13.3: type = tuple_type (i32)
-// CHECK:STDOUT:   %x: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32,) = var "x"
+// CHECK:STDOUT:   %x: ref (i32,) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_18: i32 = int_literal 4
 // CHECK:STDOUT:   %.loc7_20.1: (i32,) = tuple_literal (%.loc7_18)
 // CHECK:STDOUT:   %.loc7_20.2: init (i32,) = tuple_init %.loc7_20.1, (%.loc7_18)
-// CHECK:STDOUT:   assign %x, %.loc7_20.2
+// CHECK:STDOUT:   assign %x.var, %.loc7_20.2
 // CHECK:STDOUT:   %.loc8_13: (type,) = tuple_literal (i32)
-// CHECK:STDOUT:   %y: ref (i32,) = var "y"
+// CHECK:STDOUT:   %y.var: ref (i32,) = var "y"
+// CHECK:STDOUT:   %y: ref (i32,) = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref (i32,) = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_17.1: ref i32 = tuple_access %x.ref, member0
 // CHECK:STDOUT:   %.loc8_17.2: i32 = bind_value %.loc8_17.1
 // CHECK:STDOUT:   %.loc8_17.3: init (i32,) = tuple_init %x.ref, (%.loc8_17.2)
-// CHECK:STDOUT:   assign %y, %.loc8_17.3
+// CHECK:STDOUT:   assign %y.var, %.loc8_17.3
 // CHECK:STDOUT: }

toolchain/check/testdata/tuples/two_elements.carbon

@@ -12,27 +12,29 @@ var y: (i32, i32) = x;
 // CHECK:STDOUT:   %.loc7_17.2: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.3: type = tuple_type (i32, i32)
 // CHECK:STDOUT:   %.loc7_17.4: type = ptr_type (i32, i32)
-// CHECK:STDOUT:   %x: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x.var: ref (i32, i32) = var "x"
+// CHECK:STDOUT:   %x: ref (i32, i32) = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7_22: i32 = int_literal 4
 // CHECK:STDOUT:   %.loc7_25: i32 = int_literal 102
 // CHECK:STDOUT:   %.loc7_28.1: (i32, i32) = tuple_literal (%.loc7_22, %.loc7_25)
-// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access %x, member0
+// CHECK:STDOUT:   %.loc7_28.2: ref i32 = tuple_access %x.var, member0
 // CHECK:STDOUT:   %.loc7_28.3: init i32 = initialize_from %.loc7_22 to %.loc7_28.2
-// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access %x, member1
+// CHECK:STDOUT:   %.loc7_28.4: ref i32 = tuple_access %x.var, member1
 // CHECK:STDOUT:   %.loc7_28.5: init i32 = initialize_from %.loc7_25 to %.loc7_28.4
 // CHECK:STDOUT:   %.loc7_28.6: init (i32, i32) = tuple_init %.loc7_28.1, (%.loc7_28.3, %.loc7_28.5)
-// CHECK:STDOUT:   assign %x, %.loc7_28.6
+// CHECK:STDOUT:   assign %x.var, %.loc7_28.6
 // CHECK:STDOUT:   %.loc8_17: (type, type) = tuple_literal (i32, i32)
-// CHECK:STDOUT:   %y: ref (i32, i32) = var "y"
+// CHECK:STDOUT:   %y.var: ref (i32, i32) = var "y"
+// CHECK:STDOUT:   %y: ref (i32, i32) = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref (i32, i32) = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8_21.1: ref i32 = tuple_access %x.ref, member0
 // CHECK:STDOUT:   %.loc8_21.2: i32 = bind_value %.loc8_21.1
-// CHECK:STDOUT:   %.loc8_21.3: ref i32 = tuple_access %y, member0
+// CHECK:STDOUT:   %.loc8_21.3: ref i32 = tuple_access %y.var, member0
 // CHECK:STDOUT:   %.loc8_21.4: init i32 = initialize_from %.loc8_21.2 to %.loc8_21.3
 // CHECK:STDOUT:   %.loc8_21.5: ref i32 = tuple_access %x.ref, member1
 // CHECK:STDOUT:   %.loc8_21.6: i32 = bind_value %.loc8_21.5
-// CHECK:STDOUT:   %.loc8_21.7: ref i32 = tuple_access %y, member1
+// CHECK:STDOUT:   %.loc8_21.7: ref i32 = tuple_access %y.var, member1
 // CHECK:STDOUT:   %.loc8_21.8: init i32 = initialize_from %.loc8_21.6 to %.loc8_21.7
 // CHECK:STDOUT:   %.loc8_21.9: init (i32, i32) = tuple_init %x.ref, (%.loc8_21.4, %.loc8_21.8)
-// CHECK:STDOUT:   assign %y, %.loc8_21.9
+// CHECK:STDOUT:   assign %y.var, %.loc8_21.9
 // CHECK:STDOUT: }

toolchain/check/testdata/var/decl.carbon

@@ -14,6 +14,7 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/decl_with_init.carbon

@@ -14,8 +14,9 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x, %.loc8
+// CHECK:STDOUT:   assign %x.var, %.loc8
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/fail_duplicate_decl.carbon

@@ -22,11 +22,13 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x.loc9: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var.loc9: ref i32 = var "x"
+// CHECK:STDOUT:   %x.loc9: ref i32 = bind_name "x", %x.var.loc9
 // CHECK:STDOUT:   %.loc9: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x.loc9, %.loc9
-// CHECK:STDOUT:   %x.loc16: ref i32 = var "x"
+// CHECK:STDOUT:   assign %x.var.loc9, %.loc9
+// CHECK:STDOUT:   %x.var.loc16: ref i32 = var "x"
+// CHECK:STDOUT:   %x.loc16: ref i32 = bind_name "x", %x.var.loc16
 // CHECK:STDOUT:   %.loc16: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x.loc16, %.loc16
+// CHECK:STDOUT:   assign %x.var.loc16, %.loc16
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/fail_init_type_mismatch.carbon

@@ -17,8 +17,9 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc11: f64 = real_literal 10e-1
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/fail_init_with_self.carbon

@@ -17,8 +17,9 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %x.ref: <error> = name_reference "x", <error>
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/fail_lookup_outside_scope.carbon

@@ -15,13 +15,15 @@ var y: i32 = x;
 
 // CHECK:STDOUT: file "fail_lookup_outside_scope.carbon" {
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: <error> = name_reference "x", <error>
-// CHECK:STDOUT:   assign %y, <error>
+// CHECK:STDOUT:   assign %y.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/fail_shadowing.carbon

@@ -27,16 +27,18 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %x.loc8: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var.loc8: ref i32 = var "x"
+// CHECK:STDOUT:   %x.loc8: ref i32 = bind_name "x", %x.var.loc8
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x.loc8, %.loc8
+// CHECK:STDOUT:   assign %x.var.loc8, %.loc8
 // CHECK:STDOUT:   %.loc9: bool = bool_literal true
 // CHECK:STDOUT:   if %.loc9 br !if.then else br !if.else
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.then:
-// CHECK:STDOUT:   %x.loc18: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var.loc18: ref i32 = var "x"
+// CHECK:STDOUT:   %x.loc18: ref i32 = bind_name "x", %x.var.loc18
 // CHECK:STDOUT:   %.loc18: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x.loc18, %.loc18
+// CHECK:STDOUT:   assign %x.var.loc18, %.loc18
 // CHECK:STDOUT:   %x.ref: ref i32 = name_reference "x", %x.loc8
 // CHECK:STDOUT:   %.loc20: i32 = int_literal 1
 // CHECK:STDOUT:   assign %x.ref, %.loc20

toolchain/check/testdata/var/fail_storage_is_literal.carbon

@@ -18,8 +18,9 @@ fn Main() {
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc11_10: i32 = int_literal 1
-// CHECK:STDOUT:   %x: ref <error> = var "x"
+// CHECK:STDOUT:   %x.var: ref <error> = var "x"
+// CHECK:STDOUT:   %x: ref <error> = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc11_14: i32 = int_literal 1
-// CHECK:STDOUT:   assign %x, <error>
+// CHECK:STDOUT:   assign %x.var, <error>
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }

toolchain/check/testdata/var/global_decl.carbon

@@ -7,5 +7,6 @@
 var x: i32;
 
 // CHECK:STDOUT: file "global_decl.carbon" {
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT: }

toolchain/check/testdata/var/global_decl_with_init.carbon

@@ -7,7 +7,8 @@
 var x: i32 = 0;
 
 // CHECK:STDOUT: file "global_decl_with_init.carbon" {
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x, %.loc7
+// CHECK:STDOUT:   assign %x.var, %.loc7
 // CHECK:STDOUT: }

toolchain/check/testdata/var/global_lookup.carbon

@@ -8,11 +8,13 @@ var x: i32 = 0;
 var y: i32 = x;
 
 // CHECK:STDOUT: file "global_lookup.carbon" {
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x, %.loc7
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   assign %x.var, %.loc7
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref i32 = name_reference "x", %x
 // CHECK:STDOUT:   %.loc8: i32 = bind_value %x.ref
-// CHECK:STDOUT:   assign %y, %.loc8
+// CHECK:STDOUT:   assign %y.var, %.loc8
 // CHECK:STDOUT: }

toolchain/check/testdata/var/global_lookup_in_scope.carbon

@@ -11,17 +11,19 @@ fn Main() {
 }
 
 // CHECK:STDOUT: file "global_lookup_in_scope.carbon" {
-// CHECK:STDOUT:   %x: ref i32 = var "x"
+// CHECK:STDOUT:   %x.var: ref i32 = var "x"
+// CHECK:STDOUT:   %x: ref i32 = bind_name "x", %x.var
 // CHECK:STDOUT:   %.loc7: i32 = int_literal 0
-// CHECK:STDOUT:   assign %x, %.loc7
+// CHECK:STDOUT:   assign %x.var, %.loc7
 // CHECK:STDOUT:   %Main: <function> = fn_decl @Main
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Main() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %y: ref i32 = var "y"
+// CHECK:STDOUT:   %y.var: ref i32 = var "y"
+// CHECK:STDOUT:   %y: ref i32 = bind_name "y", %y.var
 // CHECK:STDOUT:   %x.ref: ref i32 = name_reference "x", file.%x
 // CHECK:STDOUT:   %.loc10: i32 = bind_value %x.ref
-// CHECK:STDOUT:   assign %y, %.loc10
+// CHECK:STDOUT:   assign %y.var, %.loc10
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }