From 7f2f4bec4f305bf90010aa3bbc3681df95b65bf8 Mon Sep 17 00:00:00 2001 From: Richard Smith Date: Wed, 25 Oct 2023 11:49:36 -0700 Subject: [PATCH] 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 | 14 ++++- toolchain/check/context.h | 28 +++++++++- toolchain/check/handle_class.cpp | 4 +- toolchain/check/handle_file.cpp | 21 ++++++++ toolchain/check/handle_function.cpp | 2 +- toolchain/check/handle_noop.cpp | 10 ---- toolchain/check/handle_pattern_binding.cpp | 29 ++++++++-- toolchain/check/handle_variable.cpp | 28 +++++----- toolchain/check/node_stack.h | 14 ++++- .../testdata/array/array_in_place.carbon | 11 ++-- .../testdata/array/assign_return_value.carbon | 9 ++-- .../check/testdata/array/assign_var.carbon | 24 +++++---- toolchain/check/testdata/array/base.carbon | 27 +++++----- .../testdata/array/fail_bound_overflow.carbon | 3 +- .../array/fail_incomplete_element.carbon | 8 +-- .../testdata/array/fail_invalid_type.carbon | 3 +- .../testdata/array/fail_out_of_bound.carbon | 5 +- .../testdata/array/fail_type_mismatch.carbon | 30 ++++++----- .../check/testdata/array/nine_elements.carbon | 25 ++++----- .../testdata/basics/builtin_types.carbon | 20 ++++--- .../basics/fail_non_type_as_type.carbon | 5 +- .../basics/fail_qualifier_unsupported.carbon | 8 +-- .../testdata/basics/numeric_literals.carbon | 38 ++++++------- toolchain/check/testdata/basics/parens.carbon | 5 +- toolchain/check/testdata/class/basic.carbon | 4 +- .../testdata/class/fail_incomplete.carbon | 3 +- .../testdata/class/fail_unbound_field.carbon | 53 +++++++++++++++++++ .../in_place_tuple_initialization.carbon | 7 +-- .../function/call/fail_not_callable.carbon | 5 +- .../call/fail_return_type_mismatch.carbon | 5 +- .../check/testdata/function/call/i32.carbon | 5 +- .../function/call/return_implicit.carbon | 5 +- toolchain/check/testdata/if/fail_scope.carbon | 5 +- .../testdata/if_expression/struct.carbon | 9 ++-- .../index/array_element_access.carbon | 26 +++++---- .../testdata/index/expression_category.carbon | 31 ++++++----- .../index/fail_array_large_index.carbon | 14 ++--- .../index/fail_array_non_int_indexing.carbon | 14 ++--- .../fail_array_out_of_bound_access.carbon | 14 ++--- .../index/fail_expression_category.carbon | 10 ++-- .../testdata/index/fail_invalid_base.carbon | 20 ++++--- .../testdata/index/fail_name_not_found.carbon | 5 +- .../index/fail_non_deterministic_type.carbon | 19 ++++--- .../index/fail_tuple_index_error.carbon | 14 ++--- .../index/fail_tuple_large_index.carbon | 15 +++--- .../index/fail_tuple_non_int_indexing.carbon | 14 ++--- .../fail_tuple_out_of_bound_access.carbon | 14 ++--- .../index/tuple_element_access.carbon | 15 +++--- .../ir/duplicate_name_same_line.carbon | 10 ++-- toolchain/check/testdata/let/convert.carbon | 11 ++-- .../testdata/operators/assignment.carbon | 28 +++++----- .../fail_assignment_to_non_assignable.carbon | 8 +-- .../fail_type_mismatch_assignment.carbon | 5 +- .../testdata/pointer/address_of_deref.carbon | 5 +- .../testdata/pointer/address_of_lvalue.carbon | 43 ++++++++------- toolchain/check/testdata/pointer/basic.carbon | 10 ++-- .../pointer/fail_address_of_value.carbon | 5 +- .../pointer/fail_dereference_type.carbon | 3 +- toolchain/check/testdata/struct/empty.carbon | 10 ++-- .../testdata/struct/fail_assign_empty.carbon | 5 +- .../testdata/struct/fail_assign_nested.carbon | 5 +- .../struct/fail_assign_to_empty.carbon | 5 +- .../struct/fail_field_name_mismatch.carbon | 5 +- .../struct/fail_field_type_mismatch.carbon | 5 +- .../struct/fail_member_access_type.carbon | 10 ++-- .../struct/fail_nested_incomplete.carbon | 8 +-- .../struct/fail_non_member_access.carbon | 10 ++-- .../struct/fail_too_few_values.carbon | 5 +- .../testdata/struct/fail_type_assign.carbon | 5 +- .../testdata/struct/fail_value_as_type.carbon | 3 +- .../testdata/struct/member_access.carbon | 19 ++++--- .../struct/nested_struct_in_place.carbon | 9 ++-- .../check/testdata/struct/one_entry.carbon | 10 ++-- .../testdata/struct/tuple_as_element.carbon | 18 ++++--- .../check/testdata/struct/two_entries.carbon | 18 ++++--- toolchain/check/testdata/tuples/empty.carbon | 10 ++-- .../testdata/tuples/fail_assign_empty.carbon | 5 +- .../testdata/tuples/fail_assign_nested.carbon | 5 +- .../tuples/fail_assign_to_empty.carbon | 5 +- .../tuples/fail_element_type_mismatch.carbon | 7 +-- .../tuples/fail_nested_incomplete.carbon | 8 +-- .../tuples/fail_too_few_element.carbon | 5 +- .../testdata/tuples/fail_type_assign.carbon | 5 +- .../testdata/tuples/fail_value_as_type.carbon | 3 +- .../check/testdata/tuples/nested_tuple.carbon | 9 ++-- .../tuples/nested_tuple_in_place.carbon | 20 +++---- .../check/testdata/tuples/one_element.carbon | 10 ++-- .../check/testdata/tuples/two_elements.carbon | 18 ++++--- toolchain/check/testdata/var/decl.carbon | 3 +- .../check/testdata/var/decl_with_init.carbon | 5 +- .../testdata/var/fail_duplicate_decl.carbon | 10 ++-- .../var/fail_init_type_mismatch.carbon | 5 +- .../testdata/var/fail_init_with_self.carbon | 5 +- .../var/fail_lookup_outside_scope.carbon | 8 +-- .../check/testdata/var/fail_shadowing.carbon | 10 ++-- .../var/fail_storage_is_literal.carbon | 5 +- .../check/testdata/var/global_decl.carbon | 3 +- .../testdata/var/global_decl_with_init.carbon | 5 +- .../check/testdata/var/global_lookup.carbon | 10 ++-- .../var/global_lookup_in_scope.carbon | 10 ++-- toolchain/check/testdata/var/lookup.carbon | 5 +- toolchain/lower/handle.cpp | 5 ++ toolchain/lower/handle_type.cpp | 5 ++ toolchain/sem_ir/file.cpp | 20 ++++++- toolchain/sem_ir/formatter.cpp | 16 +++--- toolchain/sem_ir/node_kind.def | 2 + toolchain/sem_ir/typed_nodes.h | 25 +++++++++ 107 files changed, 792 insertions(+), 450 deletions(-) create mode 100644 toolchain/check/handle_file.cpp create mode 100644 toolchain/check/testdata/class/fail_unbound_field.carbon diff --git a/toolchain/check/context.cpp b/toolchain/check/context.cpp index b32d07b49167..8994231026f4 100644 --- a/toolchain/check/context.cpp +++ b/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().elements_id), canonical_id); break; + case SemIR::UnboundFieldType::Kind: { + auto unbound_field_type = node.As(); + 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; } diff --git a/toolchain/check/context.h b/toolchain/check/context.h index 57a1b71cf120..f80f5f198064 100644 --- a/toolchain/check/context.h +++ b/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 + auto GetCurrentScopeAs() -> std::optional { + 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(); } // 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_; diff --git a/toolchain/check/handle_class.cpp b/toolchain/check/handle_class.cpp index 7b84ef52ee6c..86cff7c39c70 100644 --- a/toolchain/check/handle_class.cpp +++ b/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(); context.node_block_stack().Pop(); context.PopScope(); diff --git a/toolchain/check/handle_file.cpp b/toolchain/check/handle_file.cpp new file mode 100644 index 000000000000..7868dcba34f6 --- /dev/null +++ b/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 diff --git a/toolchain/check/handle_function.cpp b/toolchain/check/handle_function.cpp index 8f4dfc2f0404..b61464a4f4ae 100644 --- a/toolchain/check/handle_function.cpp +++ b/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. diff --git a/toolchain/check/handle_noop.cpp b/toolchain/check/handle_noop.cpp index a7d323227015..d7a2ea7f80e8 100644 --- a/toolchain/check/handle_noop.cpp +++ b/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"); } diff --git a/toolchain/check/handle_pattern_binding.cpp b/toolchain/check/handle_pattern_binding.cpp index bd83fa463cfa..3cd69072c20f 100644 --- a/toolchain/check/handle_pattern_binding.cpp +++ b/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(); 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: diff --git a/toolchain/check/handle_variable.cpp b/toolchain/check/handle_variable.cpp index 80af833ca5f9..15bc3a6ebb15 100644 --- a/toolchain/check/handle_variable.cpp +++ b/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(); - auto var = context.nodes().GetAs(var_id); + auto bind_name = context.nodes().GetAs(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()) { + 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() diff --git a/toolchain/check/node_stack.h b/toolchain/check/node_stack.h index 4c5be053bd28..f22d096bc151 100644 --- a/toolchain/check/node_stack.h +++ b/toolchain/check/node_stack.h @@ -140,10 +140,12 @@ class NodeStack { return PopWithParseNode().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 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()) { return function_id; } + if constexpr (std::is_same()) { + return class_id; + } if constexpr (std::is_same()) { 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: diff --git a/toolchain/check/testdata/array/array_in_place.carbon b/toolchain/check/testdata/array/array_in_place.carbon index 8602573d8a18..023a991e1d73 100644 --- a/toolchain/check/testdata/array/array_in_place.carbon +++ b/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: = 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: = 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: } diff --git a/toolchain/check/testdata/array/assign_return_value.carbon b/toolchain/check/testdata/array/assign_return_value.carbon index ec95f48e350c..59e12a0f1422 100644 --- a/toolchain/check/testdata/array/assign_return_value.carbon +++ b/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: = 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: } diff --git a/toolchain/check/testdata/array/assign_var.carbon b/toolchain/check/testdata/array/assign_var.carbon index 61ed98a03af4..be370a0338f7 100644 --- a/toolchain/check/testdata/array/assign_var.carbon +++ b/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: } diff --git a/toolchain/check/testdata/array/base.carbon b/toolchain/check/testdata/array/base.carbon index 62305a54f4a7..fee3cf4605eb 100644 --- a/toolchain/check/testdata/array/base.carbon +++ b/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: } diff --git a/toolchain/check/testdata/array/fail_bound_overflow.carbon b/toolchain/check/testdata/array/fail_bound_overflow.carbon index 48fe97db992b..9c62f8d59073 100644 --- a/toolchain/check/testdata/array/fail_bound_overflow.carbon +++ b/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 = var "a" +// CHECK:STDOUT: %a.var: ref = var "a" +// CHECK:STDOUT: %a: ref = bind_name "a", %a.var // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/array/fail_incomplete_element.carbon b/toolchain/check/testdata/array/fail_incomplete_element.carbon index 02e4733e9012..7da1ad462aa5 100644 --- a/toolchain/check/testdata/array/fail_incomplete_element.carbon +++ b/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 = var "a" +// CHECK:STDOUT: %a.var: ref = var "a" +// CHECK:STDOUT: %a: ref = 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 = name_reference "a", %a // CHECK:STDOUT: %.loc20_25: i32 = int_literal 0 // CHECK:STDOUT: %.loc20_22.1: type = ptr_type // CHECK:STDOUT: %.loc20_22.2: * = address_of -// CHECK:STDOUT: assign %p, +// CHECK:STDOUT: assign %p.var, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @Incomplete; diff --git a/toolchain/check/testdata/array/fail_invalid_type.carbon b/toolchain/check/testdata/array/fail_invalid_type.carbon index 4c3135f349cf..cdef3091c66e 100644 --- a/toolchain/check/testdata/array/fail_invalid_type.carbon +++ b/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, // CHECK:STDOUT: %.loc10_13.2: type = ptr_type [; 1] -// CHECK:STDOUT: %a: ref [; 1] = var "a" +// CHECK:STDOUT: %a.var: ref [; 1] = var "a" +// CHECK:STDOUT: %a: ref [; 1] = bind_name "a", %a.var // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/array/fail_out_of_bound.carbon b/toolchain/check/testdata/array/fail_out_of_bound.carbon index 2fa05cea3f31..285a187be0d9 100644 --- a/toolchain/check/testdata/array/fail_out_of_bound.carbon +++ b/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, +// CHECK:STDOUT: assign %a.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/array/fail_type_mismatch.carbon b/toolchain/check/testdata/array/fail_type_mismatch.carbon index b4727f74a505..c9472115927b 100644 --- a/toolchain/check/testdata/array/fail_type_mismatch.carbon +++ b/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, +// CHECK:STDOUT: assign %a.var, // 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, +// CHECK:STDOUT: assign %b.var, // 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, +// CHECK:STDOUT: assign %c.var, // 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, +// CHECK:STDOUT: assign %d.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/array/nine_elements.carbon b/toolchain/check/testdata/array/nine_elements.carbon index 67ef23f2930e..821873425673 100644 --- a/toolchain/check/testdata/array/nine_elements.carbon +++ b/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: } diff --git a/toolchain/check/testdata/basics/builtin_types.carbon b/toolchain/check/testdata/basics/builtin_types.carbon index 9ec71e92f0fe..bccbbfa0e7b8 100644 --- a/toolchain/check/testdata/basics/builtin_types.carbon +++ b/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: } diff --git a/toolchain/check/testdata/basics/fail_non_type_as_type.carbon b/toolchain/check/testdata/basics/fail_non_type_as_type.carbon index eebe4bf9285a..97c4a4337400 100644 --- a/toolchain/check/testdata/basics/fail_non_type_as_type.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/basics/fail_qualifier_unsupported.carbon b/toolchain/check/testdata/basics/fail_qualifier_unsupported.carbon index 5a0cf64991a5..a33e2625ac27 100644 --- a/toolchain/check/testdata/basics/fail_qualifier_unsupported.carbon +++ b/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, +// CHECK:STDOUT: assign %y.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/basics/numeric_literals.carbon b/toolchain/check/testdata/basics/numeric_literals.carbon index 3715ab1b1610..23434a6468f6 100644 --- a/toolchain/check/testdata/basics/numeric_literals.carbon +++ b/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: } diff --git a/toolchain/check/testdata/basics/parens.carbon b/toolchain/check/testdata/basics/parens.carbon index a9c2ff7d0876..a47c02bfc621 100644 --- a/toolchain/check/testdata/basics/parens.carbon +++ b/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: } diff --git a/toolchain/check/testdata/class/basic.carbon b/toolchain/check/testdata/class/basic.carbon index f92899262880..91909ae60388 100644 --- a/toolchain/check/testdata/class/basic.carbon +++ b/toolchain/check/testdata/class/basic.carbon @@ -32,7 +32,9 @@ fn Run() -> i32 { // CHECK:STDOUT: class @Class { // CHECK:STDOUT: %F: = fn_decl @F // CHECK:STDOUT: %G: = 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: = field "k" +// CHECK:STDOUT: %k: = bind_name "k", %.loc14_8.2 // CHECK:STDOUT: // CHECK:STDOUT: !members: // CHECK:STDOUT: .F = %F diff --git a/toolchain/check/testdata/class/fail_incomplete.carbon b/toolchain/check/testdata/class/fail_incomplete.carbon index 26a8eb2e7577..c89e8a0afce9 100644 --- a/toolchain/check/testdata/class/fail_incomplete.carbon +++ b/toolchain/check/testdata/class/fail_incomplete.carbon @@ -124,7 +124,8 @@ fn CallReturnIncomplete() { // CHECK:STDOUT: %.loc15: = fn_decl @.1 // CHECK:STDOUT: %CallClassFunction: = fn_decl @CallClassFunction // CHECK:STDOUT: %Class.ref: type = name_reference "Class", %Class -// CHECK:STDOUT: %global_var: ref = var "global_var" +// CHECK:STDOUT: %global_var.var: ref = var "global_var" +// CHECK:STDOUT: %global_var: ref = bind_name "global_var", %global_var.var // CHECK:STDOUT: %ConvertFromStruct: = fn_decl @ConvertFromStruct // CHECK:STDOUT: %MemberAccess: = fn_decl @MemberAccess // CHECK:STDOUT: %Copy: = fn_decl @Copy diff --git a/toolchain/check/testdata/class/fail_unbound_field.carbon b/toolchain/check/testdata/class/fail_unbound_field.carbon new file mode 100644 index 000000000000..60a076dc141e --- /dev/null +++ b/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: = 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: = field "field" +// CHECK:STDOUT: %field: = bind_name "field", %.loc8_12.2 +// CHECK:STDOUT: %F: = 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: = name_reference "field", +// CHECK:STDOUT: return +// 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: = name_reference "field", @Class.%field +// CHECK:STDOUT: return +// CHECK:STDOUT: } diff --git a/toolchain/check/testdata/expression_category/in_place_tuple_initialization.carbon b/toolchain/check/testdata/expression_category/in_place_tuple_initialization.carbon index ab9195e2739f..32e5cced4c4d 100644 --- a/toolchain/check/testdata/expression_category/in_place_tuple_initialization.carbon +++ b/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: = 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: = name_reference "F", file.%F // CHECK:STDOUT: %.loc11_3: ref (i32, i32) = splice_block %v.ref {} diff --git a/toolchain/check/testdata/function/call/fail_not_callable.carbon b/toolchain/check/testdata/function/call/fail_not_callable.carbon index ab4ee32c733d..fbf5ddb10517 100644 --- a/toolchain/check/testdata/function/call/fail_not_callable.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon b/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon index 08c6ae56559e..ae03a6d5fa7c 100644 --- a/toolchain/check/testdata/function/call/fail_return_type_mismatch.carbon +++ b/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: = name_reference "Foo", file.%Foo // CHECK:STDOUT: %.loc13: init f64 = call %Foo.ref() -// CHECK:STDOUT: assign %x, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/function/call/i32.carbon b/toolchain/check/testdata/function/call/i32.carbon index daa7ce5bf594..66118b99d1d7 100644 --- a/toolchain/check/testdata/function/call/i32.carbon +++ b/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: = 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: } diff --git a/toolchain/check/testdata/function/call/return_implicit.carbon b/toolchain/check/testdata/function/call/return_implicit.carbon index 898b6dabb99d..dca61214974e 100644 --- a/toolchain/check/testdata/function/call/return_implicit.carbon +++ b/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: = 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: } diff --git a/toolchain/check/testdata/if/fail_scope.carbon b/toolchain/check/testdata/if/fail_scope.carbon index 738c0e1c7979..d9395e5e7213 100644 --- a/toolchain/check/testdata/if/fail_scope.carbon +++ b/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 diff --git a/toolchain/check/testdata/if_expression/struct.carbon b/toolchain/check/testdata/if_expression/struct.carbon index deb44ba8bbbf..0b12a400a512 100644 --- a/toolchain/check/testdata/if_expression/struct.carbon +++ b/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: = 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 diff --git a/toolchain/check/testdata/index/array_element_access.carbon b/toolchain/check/testdata/index/array_element_access.carbon index 703593991d70..304c8179fe11 100644 --- a/toolchain/check/testdata/index/array_element_access.carbon +++ b/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: } diff --git a/toolchain/check/testdata/index/expression_category.carbon b/toolchain/check/testdata/index/expression_category.carbon index ff00611280bc..839cb8c791db 100644 --- a/toolchain/check/testdata/index/expression_category.carbon +++ b/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 diff --git a/toolchain/check/testdata/index/fail_array_large_index.carbon b/toolchain/check/testdata/index/fail_array_large_index.carbon index 519ce15bd7c8..787798df8418 100644 --- a/toolchain/check/testdata/index/fail_array_large_index.carbon +++ b/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, // 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: } diff --git a/toolchain/check/testdata/index/fail_array_non_int_indexing.carbon b/toolchain/check/testdata/index/fail_array_non_int_indexing.carbon index 29d85bbfc654..df80e59951d8 100644 --- a/toolchain/check/testdata/index/fail_array_non_int_indexing.carbon +++ b/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, // 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: } diff --git a/toolchain/check/testdata/index/fail_array_out_of_bound_access.carbon b/toolchain/check/testdata/index/fail_array_out_of_bound_access.carbon index a9b3db0a456a..e3813d9982d9 100644 --- a/toolchain/check/testdata/index/fail_array_out_of_bound_access.carbon +++ b/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, // 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: } diff --git a/toolchain/check/testdata/index/fail_expression_category.carbon b/toolchain/check/testdata/index/fail_expression_category.carbon index 154ceb454429..c517df62717a 100644 --- a/toolchain/check/testdata/index/fail_expression_category.carbon +++ b/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: = 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: = 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 diff --git a/toolchain/check/testdata/index/fail_invalid_base.carbon b/toolchain/check/testdata/index/fail_invalid_base.carbon index 0ebd6a3c9c53..f86330211c3f 100644 --- a/toolchain/check/testdata/index/fail_invalid_base.carbon +++ b/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 {} -// 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: = name_reference "N", %.loc11 // CHECK:STDOUT: %.loc15: i32 = int_literal 0 -// CHECK:STDOUT: assign %a, +// CHECK:STDOUT: assign %a.var, // CHECK:STDOUT: %F: = 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: = name_reference "F", %F // CHECK:STDOUT: %.loc21: i32 = int_literal 1 -// CHECK:STDOUT: assign %b, -// CHECK:STDOUT: %c: ref i32 = var "c" +// CHECK:STDOUT: assign %b.var, +// 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, -// CHECK:STDOUT: %d: ref i32 = var "d" +// CHECK:STDOUT: assign %c.var, +// 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, +// CHECK:STDOUT: assign %d.var, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: fn @F(); diff --git a/toolchain/check/testdata/index/fail_name_not_found.carbon b/toolchain/check/testdata/index/fail_name_not_found.carbon index 1ecc6bfbe739..f3a4dfbc5090 100644 --- a/toolchain/check/testdata/index/fail_name_not_found.carbon +++ b/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: = name_reference "a", // CHECK:STDOUT: %.loc11: i32 = int_literal 0 -// CHECK:STDOUT: assign %b, +// CHECK:STDOUT: assign %b.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/fail_non_deterministic_type.carbon b/toolchain/check/testdata/index/fail_non_deterministic_type.carbon index f5d76fe291d7..026cf9a10e37 100644 --- a/toolchain/check/testdata/index/fail_non_deterministic_type.carbon +++ b/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 = tuple_index %a.ref, -// CHECK:STDOUT: assign %c, +// CHECK:STDOUT: assign %c.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/fail_tuple_index_error.carbon b/toolchain/check/testdata/index/fail_tuple_index_error.carbon index c187c93d64c1..cb7de27d84fc 100644 --- a/toolchain/check/testdata/index/fail_tuple_index_error.carbon +++ b/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: = name_reference "oops", // CHECK:STDOUT: %.loc11: ref = tuple_index %a.ref, %oops.ref -// CHECK:STDOUT: assign %b, +// CHECK:STDOUT: assign %b.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/fail_tuple_large_index.carbon b/toolchain/check/testdata/index/fail_tuple_large_index.carbon index 55004b1a95b6..62e4094881fc 100644 --- a/toolchain/check/testdata/index/fail_tuple_large_index.carbon +++ b/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 = tuple_index %b.ref, -// CHECK:STDOUT: assign %c, +// CHECK:STDOUT: assign %c.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/fail_tuple_non_int_indexing.carbon b/toolchain/check/testdata/index/fail_tuple_non_int_indexing.carbon index 66aa8bd2b656..22d91b3e5ece 100644 --- a/toolchain/check/testdata/index/fail_tuple_non_int_indexing.carbon +++ b/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 = tuple_index %a.ref, -// CHECK:STDOUT: assign %b, +// CHECK:STDOUT: assign %b.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/fail_tuple_out_of_bound_access.carbon b/toolchain/check/testdata/index/fail_tuple_out_of_bound_access.carbon index 8d5cb8c1cb26..86d3cd80c5db 100644 --- a/toolchain/check/testdata/index/fail_tuple_out_of_bound_access.carbon +++ b/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 = tuple_index %a.ref, -// CHECK:STDOUT: assign %b, +// CHECK:STDOUT: assign %b.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/index/tuple_element_access.carbon b/toolchain/check/testdata/index/tuple_element_access.carbon index b750536dad62..ff84533e5444 100644 --- a/toolchain/check/testdata/index/tuple_element_access.carbon +++ b/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: } diff --git a/toolchain/check/testdata/ir/duplicate_name_same_line.carbon b/toolchain/check/testdata/ir/duplicate_name_same_line.carbon index 6f4b28d0266e..8351e2aa0fd8 100644 --- a/toolchain/check/testdata/ir/duplicate_name_same_line.carbon +++ b/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: diff --git a/toolchain/check/testdata/let/convert.carbon b/toolchain/check/testdata/let/convert.carbon index f36e70acf1b1..66747cdd3892 100644 --- a/toolchain/check/testdata/let/convert.carbon +++ b/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 diff --git a/toolchain/check/testdata/operators/assignment.carbon b/toolchain/check/testdata/operators/assignment.carbon index 656acc98a059..3407a1ce01a7 100644 --- a/toolchain/check/testdata/operators/assignment.carbon +++ b/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 diff --git a/toolchain/check/testdata/operators/fail_assignment_to_non_assignable.carbon b/toolchain/check/testdata/operators/fail_assignment_to_non_assignable.carbon index 3044aed3ab03..ce8c98a5f33f 100644 --- a/toolchain/check/testdata/operators/fail_assignment_to_non_assignable.carbon +++ b/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: diff --git a/toolchain/check/testdata/operators/fail_type_mismatch_assignment.carbon b/toolchain/check/testdata/operators/fail_type_mismatch_assignment.carbon index 479a20579f30..ebf2cf74c757 100644 --- a/toolchain/check/testdata/operators/fail_type_mismatch_assignment.carbon +++ b/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, diff --git a/toolchain/check/testdata/pointer/address_of_deref.carbon b/toolchain/check/testdata/pointer/address_of_deref.carbon index 6e7d42d4ab70..b55e7f1a32cd 100644 --- a/toolchain/check/testdata/pointer/address_of_deref.carbon +++ b/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 diff --git a/toolchain/check/testdata/pointer/address_of_lvalue.carbon b/toolchain/check/testdata/pointer/address_of_lvalue.carbon index 1b687682fc70..98a0166947e1 100644 --- a/toolchain/check/testdata/pointer/address_of_lvalue.carbon +++ b/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: } diff --git a/toolchain/check/testdata/pointer/basic.carbon b/toolchain/check/testdata/pointer/basic.carbon index f7712bba67d6..df1315c1e1c3 100644 --- a/toolchain/check/testdata/pointer/basic.carbon +++ b/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 diff --git a/toolchain/check/testdata/pointer/fail_address_of_value.carbon b/toolchain/check/testdata/pointer/fail_address_of_value.carbon index f7ff93abce97..ae20983d15dd 100644 --- a/toolchain/check/testdata/pointer/fail_address_of_value.carbon +++ b/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: } diff --git a/toolchain/check/testdata/pointer/fail_dereference_type.carbon b/toolchain/check/testdata/pointer/fail_dereference_type.carbon index c19220cdbb7d..16164d0f269b 100644 --- a/toolchain/check/testdata/pointer/fail_dereference_type.carbon +++ b/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 = dereference i32 -// CHECK:STDOUT: %p: ref = var "p" +// CHECK:STDOUT: %p.var: ref = var "p" +// CHECK:STDOUT: %p: ref = bind_name "p", %p.var // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/empty.carbon b/toolchain/check/testdata/struct/empty.carbon index 0c91dc7ae234..c865b28714a1 100644 --- a/toolchain/check/testdata/struct/empty.carbon +++ b/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: } diff --git a/toolchain/check/testdata/struct/fail_assign_empty.carbon b/toolchain/check/testdata/struct/fail_assign_empty.carbon index 8bb50da638f8..bc113a71a5eb 100644 --- a/toolchain/check/testdata/struct/fail_assign_empty.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_assign_nested.carbon b/toolchain/check/testdata/struct/fail_assign_nested.carbon index d205599f0879..d3699c43acee 100644 --- a/toolchain/check/testdata/struct/fail_assign_nested.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_assign_to_empty.carbon b/toolchain/check/testdata/struct/fail_assign_to_empty.carbon index 52862c1c7122..3a86560a84d0 100644 --- a/toolchain/check/testdata/struct/fail_assign_to_empty.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_field_name_mismatch.carbon b/toolchain/check/testdata/struct/fail_field_name_mismatch.carbon index 07aabb522269..4f4e59a9d5f0 100644 --- a/toolchain/check/testdata/struct/fail_field_name_mismatch.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_field_type_mismatch.carbon b/toolchain/check/testdata/struct/fail_field_type_mismatch.carbon index 6712a6861864..8f5e4f71a08c 100644 --- a/toolchain/check/testdata/struct/fail_field_type_mismatch.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_member_access_type.carbon b/toolchain/check/testdata/struct/fail_member_access_type.carbon index eed156857abf..ec0738c3e3b0 100644 --- a/toolchain/check/testdata/struct/fail_member_access_type.carbon +++ b/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, +// CHECK:STDOUT: assign %y.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_nested_incomplete.carbon b/toolchain/check/testdata/struct/fail_nested_incomplete.carbon index d5684b98b6bf..757b85bcc85e 100644 --- a/toolchain/check/testdata/struct/fail_nested_incomplete.carbon +++ b/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 = var "s" +// CHECK:STDOUT: %s.var: ref = var "s" +// CHECK:STDOUT: %s: ref = 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 = name_reference "s", %s // CHECK:STDOUT: %.loc20_22.1: type = ptr_type // CHECK:STDOUT: %.loc20_22.2: * = address_of -// CHECK:STDOUT: assign %p, +// CHECK:STDOUT: assign %p.var, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @Incomplete; diff --git a/toolchain/check/testdata/struct/fail_non_member_access.carbon b/toolchain/check/testdata/struct/fail_non_member_access.carbon index 1fd2ffde846f..715ea50bb21b 100644 --- a/toolchain/check/testdata/struct/fail_non_member_access.carbon +++ b/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, +// CHECK:STDOUT: assign %y.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_too_few_values.carbon b/toolchain/check/testdata/struct/fail_too_few_values.carbon index 10ef90d301a4..61c0f9b11251 100644 --- a/toolchain/check/testdata/struct/fail_too_few_values.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_type_assign.carbon b/toolchain/check/testdata/struct/fail_type_assign.carbon index 0468d4e03813..880b8d361a85 100644 --- a/toolchain/check/testdata/struct/fail_type_assign.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/fail_value_as_type.carbon b/toolchain/check/testdata/struct/fail_value_as_type.carbon index 18f2f0b93853..0eaeee30614e 100644 --- a/toolchain/check/testdata/struct/fail_value_as_type.carbon +++ b/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 = var "x" +// CHECK:STDOUT: %x.var: ref = var "x" +// CHECK:STDOUT: %x: ref = bind_name "x", %x.var // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/struct/member_access.carbon b/toolchain/check/testdata/struct/member_access.carbon index 2da174bec0a9..7b1c1fa17bd7 100644 --- a/toolchain/check/testdata/struct/member_access.carbon +++ b/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: } diff --git a/toolchain/check/testdata/struct/nested_struct_in_place.carbon b/toolchain/check/testdata/struct/nested_struct_in_place.carbon index 3493cfd4d624..e58947a148be 100644 --- a/toolchain/check/testdata/struct/nested_struct_in_place.carbon +++ b/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: = 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: = 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: } diff --git a/toolchain/check/testdata/struct/one_entry.carbon b/toolchain/check/testdata/struct/one_entry.carbon index 65e114bb1042..16d88d97d3d3 100644 --- a/toolchain/check/testdata/struct/one_entry.carbon +++ b/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: } diff --git a/toolchain/check/testdata/struct/tuple_as_element.carbon b/toolchain/check/testdata/struct/tuple_as_element.carbon index cca201661b8c..281f06f788e9 100644 --- a/toolchain/check/testdata/struct/tuple_as_element.carbon +++ b/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: } diff --git a/toolchain/check/testdata/struct/two_entries.carbon b/toolchain/check/testdata/struct/two_entries.carbon index 751b44b35edd..2f594eb379d5 100644 --- a/toolchain/check/testdata/struct/two_entries.carbon +++ b/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: } diff --git a/toolchain/check/testdata/tuples/empty.carbon b/toolchain/check/testdata/tuples/empty.carbon index dfc83024954c..e4b84b999255 100644 --- a/toolchain/check/testdata/tuples/empty.carbon +++ b/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: } diff --git a/toolchain/check/testdata/tuples/fail_assign_empty.carbon b/toolchain/check/testdata/tuples/fail_assign_empty.carbon index cbf63a0106a2..95cc1313e15c 100644 --- a/toolchain/check/testdata/tuples/fail_assign_empty.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_assign_nested.carbon b/toolchain/check/testdata/tuples/fail_assign_nested.carbon index 0e095e1ab023..85ba92438317 100644 --- a/toolchain/check/testdata/tuples/fail_assign_nested.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_assign_to_empty.carbon b/toolchain/check/testdata/tuples/fail_assign_to_empty.carbon index 1a65235c81c5..d0821d9f8046 100644 --- a/toolchain/check/testdata/tuples/fail_assign_to_empty.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_element_type_mismatch.carbon b/toolchain/check/testdata/tuples/fail_element_type_mismatch.carbon index e6cb299266cb..06929313c19b 100644 --- a/toolchain/check/testdata/tuples/fail_element_type_mismatch.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon b/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon index 745cfc471c37..d8ee632f8cd7 100644 --- a/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon +++ b/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 = var "t" +// CHECK:STDOUT: %t.var: ref = var "t" +// CHECK:STDOUT: %t: ref = 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 = name_reference "t", %t // CHECK:STDOUT: %.loc20_25: i32 = int_literal 1 // CHECK:STDOUT: %.loc20_22.1: type = ptr_type // CHECK:STDOUT: %.loc20_22.2: * = address_of -// CHECK:STDOUT: assign %p, +// CHECK:STDOUT: assign %p.var, // CHECK:STDOUT: } // CHECK:STDOUT: // CHECK:STDOUT: class @Incomplete; diff --git a/toolchain/check/testdata/tuples/fail_too_few_element.carbon b/toolchain/check/testdata/tuples/fail_too_few_element.carbon index 002e9b488a38..61a002d4a4fa 100644 --- a/toolchain/check/testdata/tuples/fail_too_few_element.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_type_assign.carbon b/toolchain/check/testdata/tuples/fail_type_assign.carbon index 04b72cb1671b..486ff5dbdba1 100644 --- a/toolchain/check/testdata/tuples/fail_type_assign.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/fail_value_as_type.carbon b/toolchain/check/testdata/tuples/fail_value_as_type.carbon index 8e0a1af1ac55..d4a58c8983a8 100644 --- a/toolchain/check/testdata/tuples/fail_value_as_type.carbon +++ b/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 () -// CHECK:STDOUT: %x: ref (,) = var "x" +// CHECK:STDOUT: %x.var: ref (,) = var "x" +// CHECK:STDOUT: %x: ref (,) = bind_name "x", %x.var // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/tuples/nested_tuple.carbon b/toolchain/check/testdata/tuples/nested_tuple.carbon index 7519202c50c2..8a62f3f06341 100644 --- a/toolchain/check/testdata/tuples/nested_tuple.carbon +++ b/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: } diff --git a/toolchain/check/testdata/tuples/nested_tuple_in_place.carbon b/toolchain/check/testdata/tuples/nested_tuple_in_place.carbon index 193f52d0400c..d0fefd703c74 100644 --- a/toolchain/check/testdata/tuples/nested_tuple_in_place.carbon +++ b/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: = 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: = 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: = 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: } diff --git a/toolchain/check/testdata/tuples/one_element.carbon b/toolchain/check/testdata/tuples/one_element.carbon index a07944f8cc00..ff7f72338b97 100644 --- a/toolchain/check/testdata/tuples/one_element.carbon +++ b/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: } diff --git a/toolchain/check/testdata/tuples/two_elements.carbon b/toolchain/check/testdata/tuples/two_elements.carbon index ab250e4e35d6..7cf08a4a45eb 100644 --- a/toolchain/check/testdata/tuples/two_elements.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/decl.carbon b/toolchain/check/testdata/var/decl.carbon index 7812934ea814..235826d36397 100644 --- a/toolchain/check/testdata/var/decl.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/decl_with_init.carbon b/toolchain/check/testdata/var/decl_with_init.carbon index a487e40a7d84..e8ca5c96f35e 100644 --- a/toolchain/check/testdata/var/decl_with_init.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/fail_duplicate_decl.carbon b/toolchain/check/testdata/var/fail_duplicate_decl.carbon index e9fdaff8a52a..1e82080a43ec 100644 --- a/toolchain/check/testdata/var/fail_duplicate_decl.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/fail_init_type_mismatch.carbon b/toolchain/check/testdata/var/fail_init_type_mismatch.carbon index 65200db3c234..4c09e84296ce 100644 --- a/toolchain/check/testdata/var/fail_init_type_mismatch.carbon +++ b/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, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/var/fail_init_with_self.carbon b/toolchain/check/testdata/var/fail_init_with_self.carbon index 3925d5ce3b5c..f511f0315614 100644 --- a/toolchain/check/testdata/var/fail_init_with_self.carbon +++ b/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: = name_reference "x", -// CHECK:STDOUT: assign %x, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/var/fail_lookup_outside_scope.carbon b/toolchain/check/testdata/var/fail_lookup_outside_scope.carbon index eba2ce542f96..afa7f379fae8 100644 --- a/toolchain/check/testdata/var/fail_lookup_outside_scope.carbon +++ b/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: = 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: = name_reference "x", -// CHECK:STDOUT: assign %y, +// CHECK:STDOUT: assign %y.var, // 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: } diff --git a/toolchain/check/testdata/var/fail_shadowing.carbon b/toolchain/check/testdata/var/fail_shadowing.carbon index 03ccdb854718..1dfc5cbe2457 100644 --- a/toolchain/check/testdata/var/fail_shadowing.carbon +++ b/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 diff --git a/toolchain/check/testdata/var/fail_storage_is_literal.carbon b/toolchain/check/testdata/var/fail_storage_is_literal.carbon index d4c39f34520b..7291b49ea305 100644 --- a/toolchain/check/testdata/var/fail_storage_is_literal.carbon +++ b/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 = var "x" +// CHECK:STDOUT: %x.var: ref = var "x" +// CHECK:STDOUT: %x: ref = bind_name "x", %x.var // CHECK:STDOUT: %.loc11_14: i32 = int_literal 1 -// CHECK:STDOUT: assign %x, +// CHECK:STDOUT: assign %x.var, // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/check/testdata/var/global_decl.carbon b/toolchain/check/testdata/var/global_decl.carbon index d8f1e8ae878c..aa481ec563fc 100644 --- a/toolchain/check/testdata/var/global_decl.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/global_decl_with_init.carbon b/toolchain/check/testdata/var/global_decl_with_init.carbon index 762c486e7ec6..99e55c922aca 100644 --- a/toolchain/check/testdata/var/global_decl_with_init.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/global_lookup.carbon b/toolchain/check/testdata/var/global_lookup.carbon index ce29fe6daa5e..7ec8907a6127 100644 --- a/toolchain/check/testdata/var/global_lookup.carbon +++ b/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: } diff --git a/toolchain/check/testdata/var/global_lookup_in_scope.carbon b/toolchain/check/testdata/var/global_lookup_in_scope.carbon index be06d8dc95f7..dd8272085d8d 100644 --- a/toolchain/check/testdata/var/global_lookup_in_scope.carbon +++ b/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: = 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: } diff --git a/toolchain/check/testdata/var/lookup.carbon b/toolchain/check/testdata/var/lookup.carbon index c78df4e3828c..e4f1af04baa6 100644 --- a/toolchain/check/testdata/var/lookup.carbon +++ b/toolchain/check/testdata/var/lookup.carbon @@ -15,9 +15,10 @@ 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: %x.ref: ref i32 = name_reference "x", %x // CHECK:STDOUT: return // CHECK:STDOUT: } diff --git a/toolchain/lower/handle.cpp b/toolchain/lower/handle.cpp index a52e5fa97952..810275864118 100644 --- a/toolchain/lower/handle.cpp +++ b/toolchain/lower/handle.cpp @@ -171,6 +171,11 @@ auto HandleDereference(FunctionContext& context, SemIR::NodeId node_id, context.SetLocal(node_id, context.GetLocal(node.pointer_id)); } +auto HandleField(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/, + SemIR::Field /*node*/) -> void { + // No action to perform. +} + auto HandleFunctionDeclaration(FunctionContext& /*context*/, SemIR::NodeId /*node_id*/, SemIR::FunctionDeclaration node) -> void { diff --git a/toolchain/lower/handle_type.cpp b/toolchain/lower/handle_type.cpp index a5f69d06c972..6a7dd033c6b0 100644 --- a/toolchain/lower/handle_type.cpp +++ b/toolchain/lower/handle_type.cpp @@ -36,4 +36,9 @@ auto HandleTupleType(FunctionContext& context, SemIR::NodeId node_id, context.SetLocal(node_id, context.GetTypeAsValue()); } +auto HandleUnboundFieldType(FunctionContext& context, SemIR::NodeId node_id, + SemIR::UnboundFieldType /*node*/) -> void { + context.SetLocal(node_id, context.GetTypeAsValue()); +} + } // namespace Carbon::Lower diff --git a/toolchain/sem_ir/file.cpp b/toolchain/sem_ir/file.cpp index 9f7446c3566f..6102d67aa704 100644 --- a/toolchain/sem_ir/file.cpp +++ b/toolchain/sem_ir/file.cpp @@ -161,11 +161,11 @@ static auto GetTypePrecedence(NodeKind kind) -> int { switch (kind) { case ArrayType::Kind: case Builtin::Kind: - case ClassDeclaration::Kind: + case ClassType::Kind: case NameReference::Kind: case StructType::Kind: case TupleType::Kind: - case ClassType::Kind: + case UnboundFieldType::Kind: return 0; case ConstType::Kind: return -1; @@ -191,7 +191,9 @@ static auto GetTypePrecedence(NodeKind kind) -> int { case BranchIf::Kind: case BranchWithArg::Kind: case Call::Kind: + case ClassDeclaration::Kind: case Dereference::Kind: + case Field::Kind: case FunctionDeclaration::Kind: case InitializeFrom::Kind: case IntegerLiteral::Kind: @@ -361,6 +363,17 @@ auto File::StringifyTypeExpression(NodeId outer_node_id, {.node_id = GetTypeAllowBuiltinTypes(refs[step.index])}); break; } + case UnboundFieldType::Kind: { + if (step.index == 0) { + out << "().class_type_id)}); + } else { + out << ">"; + } + break; + } case AddressOf::Kind: case ArrayIndex::Kind: case ArrayInit::Kind: @@ -378,6 +391,7 @@ auto File::StringifyTypeExpression(NodeId outer_node_id, case ClassDeclaration::Kind: case CrossReference::Kind: case Dereference::Kind: + case Field::Kind: case FunctionDeclaration::Kind: case InitializeFrom::Kind: case IntegerLiteral::Kind: @@ -438,6 +452,7 @@ auto GetExpressionCategory(const File& file, NodeId node_id) case BranchIf::Kind: case BranchWithArg::Kind: case ClassDeclaration::Kind: + case Field::Kind: case FunctionDeclaration::Kind: case Namespace::Kind: case NoOp::Kind: @@ -476,6 +491,7 @@ auto GetExpressionCategory(const File& file, NodeId node_id) case TupleValue::Kind: case TupleType::Kind: case UnaryOperatorNot::Kind: + case UnboundFieldType::Kind: return ExpressionCategory::Value; case Builtin::Kind: { diff --git a/toolchain/sem_ir/formatter.cpp b/toolchain/sem_ir/formatter.cpp index b7eb6d4a1cb6..ea3ff75010c9 100644 --- a/toolchain/sem_ir/formatter.cpp +++ b/toolchain/sem_ir/formatter.cpp @@ -385,11 +385,12 @@ class NodeNamer { nodes[node_id.index] = {scope_idx, scope.nodes.AllocateName( *this, node.parse_node(), name)}; }; - auto add_node_name_id = [&](StringId name_id) { + auto add_node_name_id = [&](StringId name_id, + llvm::StringRef suffix = "") { if (name_id.is_valid()) { - add_node_name(sem_ir_.strings().Get(name_id).str()); + add_node_name((sem_ir_.strings().Get(name_id).str() + suffix).str()); } else { - add_node_name(""); + add_node_name(suffix.str()); } }; @@ -426,9 +427,7 @@ class NodeNamer { continue; } case NameReference::Kind: { - add_node_name( - sem_ir_.strings().Get(node.As().name_id).str() + - ".ref"); + add_node_name_id(node.As().name_id, ".ref"); continue; } case Parameter::Kind: { @@ -436,10 +435,7 @@ class NodeNamer { continue; } case VarStorage::Kind: { - // TODO: Eventually this name will be optional, and we'll want to - // provide something like `var` as a default. However, that's not - // possible right now so cannot be tested. - add_node_name_id(node.As().name_id); + add_node_name_id(node.As().name_id, ".var"); continue; } default: { diff --git a/toolchain/sem_ir/node_kind.def b/toolchain/sem_ir/node_kind.def index 699671445f91..3a8a0f44e7ed 100644 --- a/toolchain/sem_ir/node_kind.def +++ b/toolchain/sem_ir/node_kind.def @@ -37,6 +37,7 @@ CARBON_SEM_IR_NODE_KIND(ClassType) CARBON_SEM_IR_NODE_KIND(ConstType) CARBON_SEM_IR_NODE_KIND(CrossReference) CARBON_SEM_IR_NODE_KIND(Dereference) +CARBON_SEM_IR_NODE_KIND(Field) CARBON_SEM_IR_NODE_KIND(FunctionDeclaration) CARBON_SEM_IR_NODE_KIND(InitializeFrom) CARBON_SEM_IR_NODE_KIND(IntegerLiteral) @@ -65,6 +66,7 @@ CARBON_SEM_IR_NODE_KIND(TupleLiteral) CARBON_SEM_IR_NODE_KIND(TupleType) CARBON_SEM_IR_NODE_KIND(TupleValue) CARBON_SEM_IR_NODE_KIND(UnaryOperatorNot) +CARBON_SEM_IR_NODE_KIND(UnboundFieldType) CARBON_SEM_IR_NODE_KIND(ValueAsReference) CARBON_SEM_IR_NODE_KIND(VarStorage) diff --git a/toolchain/sem_ir/typed_nodes.h b/toolchain/sem_ir/typed_nodes.h index 031c6d1fc082..20de2ece0a09 100644 --- a/toolchain/sem_ir/typed_nodes.h +++ b/toolchain/sem_ir/typed_nodes.h @@ -227,6 +227,16 @@ struct Dereference { NodeId pointer_id; }; +// A field in a class, of the form `var field: field_type;`. The type of the +// `Field` node is an `UnboundFieldType`. +struct Field { + static constexpr auto Kind = NodeKind::Field.Define("field"); + + Parse::Node parse_node; + TypeId type_id; + StringId name_id; +}; + struct FunctionDeclaration { static constexpr auto Kind = NodeKind::FunctionDeclaration.Define("fn_decl"); @@ -469,6 +479,21 @@ struct UnaryOperatorNot { NodeId operand_id; }; +// The type of an expression naming an unbound field, such as `Class.field`. +// This can be used as the operand of a compound member access expression, +// such as `instance.(Class.field)`. +struct UnboundFieldType { + static constexpr auto Kind = + NodeKind::UnboundFieldType.Define("unbound_field_type"); + + Parse::Node parse_node; + TypeId type_id; + // The class of which the field is a member. + TypeId class_type_id; + // The type of the field. + TypeId field_type_id; +}; + struct ValueAsReference { static constexpr auto Kind = NodeKind::ValueAsReference.Define("value_as_reference");