From f5c34d62dd302bd0b78e496588e13b2325d728c3 Mon Sep 17 00:00:00 2001
From: josh11b <josh11b@users.noreply.github.com>
Date: Tue, 9 Jan 2024 14:37:48 -0800
Subject: [PATCH] Abbreviate "address" -> "addr" (#3580)

As [requested in
Discord](https://discord.com/channels/655572317891461132/655578254970716160/1184904724483416064)
and is now documented in [the toolchain architecture
doc](https://docs.google.com/document/d/1RRYMm42osyqhI2LyjrjockYCutQ5dOf8Abu50kTrkX0/edit?resourcekey=0-kHyqOESbOHmzZphUbtLrTw&tab=t.0#heading=h.pph7i5m5un7q).
---
 toolchain/check/context.cpp                   |  2 +-
 toolchain/check/convert.cpp                   | 11 ++++----
 toolchain/check/handle_binding_pattern.cpp    |  2 +-
 toolchain/check/handle_operator.cpp           | 16 +++++------
 toolchain/check/node_stack.h                  |  2 +-
 .../array/fail_incomplete_element.carbon      |  2 +-
 toolchain/check/testdata/as/identity.carbon   |  2 +-
 .../check/testdata/class/base_field.carbon    |  2 +-
 .../check/testdata/class/base_method.carbon   |  4 +--
 .../testdata/class/base_method_shadow.carbon  | 10 +++----
 .../testdata/class/derived_to_base.carbon     |  8 +++---
 .../testdata/class/fail_addr_self.carbon      |  4 +--
 .../testdata/class/fail_base_bad_type.carbon  |  2 +-
 .../class/fail_init_as_inplace.carbon         |  2 +-
 toolchain/check/testdata/class/method.carbon  |  6 ++--
 .../testdata/class/self_conversion.carbon     |  4 +--
 .../check/testdata/index/expr_category.carbon |  2 +-
 .../testdata/index/fail_expr_category.carbon  |  4 +--
 .../testdata/operators/assignment.carbon      |  4 +--
 .../testdata/pointer/address_of_deref.carbon  |  4 +--
 .../testdata/pointer/address_of_lvalue.carbon | 10 +++----
 toolchain/check/testdata/pointer/basic.carbon |  2 +-
 .../pointer/fail_address_of_error.carbon      |  6 ++--
 .../pointer/fail_address_of_value.carbon      | 28 +++++++++----------
 .../struct/fail_nested_incomplete.carbon      |  2 +-
 .../tuples/fail_nested_incomplete.carbon      |  2 +-
 toolchain/diagnostics/diagnostic_kind.def     |  4 +--
 toolchain/lower/handle.cpp                    |  4 +--
 toolchain/parse/handle_binding_pattern.cpp    |  6 ++--
 toolchain/parse/node_kind.def                 |  4 +--
 toolchain/parse/state.def                     |  4 +--
 .../testdata/class/fn_definitions.carbon      |  2 +-
 .../testdata/function/declaration/addr.carbon |  2 +-
 .../generic_params/template_addr.carbon       |  2 +-
 .../generics/interface/self_pointer.carbon    |  4 +--
 toolchain/parse/typed_nodes.h                 |  4 +--
 toolchain/sem_ir/file.cpp                     |  6 ++--
 toolchain/sem_ir/inst_kind.def                |  2 +-
 toolchain/sem_ir/typed_insts.h                |  6 ++--
 39 files changed, 96 insertions(+), 97 deletions(-)

diff --git a/toolchain/check/context.cpp b/toolchain/check/context.cpp
index d990dd4a079d..a3ee68432c97 100644
--- a/toolchain/check/context.cpp
+++ b/toolchain/check/context.cpp
@@ -923,7 +923,7 @@ class TypeCompleter {
     // clang warns on unhandled enum values; clang-tidy is incorrect here.
     // NOLINTNEXTLINE(bugprone-switch-missing-default-case)
     switch (inst.kind()) {
-      case SemIR::AddressOf::Kind:
+      case SemIR::AddrOf::Kind:
       case SemIR::AddrPattern::Kind:
       case SemIR::ArrayIndex::Kind:
       case SemIR::ArrayInit::Kind:
diff --git a/toolchain/check/convert.cpp b/toolchain/check/convert.cpp
index 42db7800cd28..0ef53047073d 100644
--- a/toolchain/check/convert.cpp
+++ b/toolchain/check/convert.cpp
@@ -645,8 +645,7 @@ static auto ConvertDerivedPointerToBasePointer(
   ref_id = ConvertDerivedToBase(context, parse_node, ref_id, path);
 
   // Take the address.
-  return context.AddInst(
-      SemIR::AddressOf{parse_node, dest_ptr_type_id, ref_id});
+  return context.AddInst(SemIR::AddrOf{parse_node, dest_ptr_type_id, ref_id});
 }
 
 // Returns whether `category` is a valid expression category to produce as a
@@ -1108,10 +1107,10 @@ static auto ConvertSelf(Context& context, Parse::NodeId call_parse_node,
         context.emitter().Emit(TokenOnly(call_parse_node), AddrSelfIsNonRef);
         return SemIR::InstId::BuiltinError;
     }
-    self_or_addr_id = context.AddInst(SemIR::AddressOf{
-        self.parse_node(),
-        context.GetPointerType(self.parse_node(), self.type_id()),
-        self_or_addr_id});
+    self_or_addr_id = context.AddInst(
+        SemIR::AddrOf{self.parse_node(),
+                      context.GetPointerType(self.parse_node(), self.type_id()),
+                      self_or_addr_id});
   }
 
   return ConvertToValueOfType(context, call_parse_node, self_or_addr_id,
diff --git a/toolchain/check/handle_binding_pattern.cpp b/toolchain/check/handle_binding_pattern.cpp
index 694df1a75335..d050eaef761c 100644
--- a/toolchain/check/handle_binding_pattern.cpp
+++ b/toolchain/check/handle_binding_pattern.cpp
@@ -165,7 +165,7 @@ auto HandleGenericBindingPattern(Context& context,
   return HandleAnyBindingPattern(context, parse_node, /*is_generic=*/true);
 }
 
-auto HandleAddress(Context& context, Parse::AddressId parse_node) -> bool {
+auto HandleAddr(Context& context, Parse::AddrId parse_node) -> bool {
   auto self_param_id = context.node_stack().PopPattern();
   if (auto self_param =
           context.insts().TryGetAs<SemIR::AnyBindName>(self_param_id);
diff --git a/toolchain/check/handle_operator.cpp b/toolchain/check/handle_operator.cpp
index f8e3f2d9e0eb..16c5fab16d80 100644
--- a/toolchain/check/handle_operator.cpp
+++ b/toolchain/check/handle_operator.cpp
@@ -213,22 +213,22 @@ auto HandlePrefixOperatorAmp(Context& context,
     case SemIR::ExprCategory::Error:
       break;
     case SemIR::ExprCategory::EphemeralRef:
-      CARBON_DIAGNOSTIC(AddressOfEphemeralRef, Error,
+      CARBON_DIAGNOSTIC(AddrOfEphemeralRef, Error,
                         "Cannot take the address of a temporary object.");
-      context.emitter().Emit(TokenOnly(parse_node), AddressOfEphemeralRef);
+      context.emitter().Emit(TokenOnly(parse_node), AddrOfEphemeralRef);
       break;
     default:
-      CARBON_DIAGNOSTIC(AddressOfNonRef, Error,
+      CARBON_DIAGNOSTIC(AddrOfNonRef, Error,
                         "Cannot take the address of non-reference expression.");
-      context.emitter().Emit(TokenOnly(parse_node), AddressOfNonRef);
+      context.emitter().Emit(TokenOnly(parse_node), AddrOfNonRef);
       break;
   }
   context.AddInstAndPush(
       parse_node,
-      SemIR::AddressOf{parse_node,
-                       context.GetPointerType(
-                           parse_node, context.insts().Get(value_id).type_id()),
-                       value_id});
+      SemIR::AddrOf{parse_node,
+                    context.GetPointerType(
+                        parse_node, context.insts().Get(value_id).type_id()),
+                    value_id});
   return true;
 }
 
diff --git a/toolchain/check/node_stack.h b/toolchain/check/node_stack.h
index 25fe469d1f7b..d3e677f7c113 100644
--- a/toolchain/check/node_stack.h
+++ b/toolchain/check/node_stack.h
@@ -366,7 +366,7 @@ class NodeStack {
   // Translate a parse node kind to the enum ID kind it should always provide.
   static constexpr auto ParseNodeKindToIdKind(Parse::NodeKind kind) -> IdKind {
     switch (kind) {
-      case Parse::NodeKind::Address:
+      case Parse::NodeKind::Addr:
       case Parse::NodeKind::ArrayExpr:
       case Parse::NodeKind::BindingPattern:
       case Parse::NodeKind::CallExpr:
diff --git a/toolchain/check/testdata/array/fail_incomplete_element.carbon b/toolchain/check/testdata/array/fail_incomplete_element.carbon
index e80631bfca30..883507f3b65a 100644
--- a/toolchain/check/testdata/array/fail_incomplete_element.carbon
+++ b/toolchain/check/testdata/array/fail_incomplete_element.carbon
@@ -40,7 +40,7 @@ var p: Incomplete* = &a[0];
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
 // CHECK:STDOUT:   %a.ref: ref <error> = name_ref a, %a
 // CHECK:STDOUT:   %.loc20_25: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc20_22: <error>* = address_of <error>
+// CHECK:STDOUT:   %.loc20_22: <error>* = addr_of <error>
 // CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/check/testdata/as/identity.carbon b/toolchain/check/testdata/as/identity.carbon
index 3771527f35e7..951a2807a3f8 100644
--- a/toolchain/check/testdata/as/identity.carbon
+++ b/toolchain/check/testdata/as/identity.carbon
@@ -63,7 +63,7 @@ fn Initializing() {
 // CHECK:STDOUT:   %p.ref: X* = name_ref p, %p
 // CHECK:STDOUT:   %.loc18_17: ref X = deref %p.ref
 // CHECK:STDOUT:   %X.ref.loc18_23: type = name_ref X, file.%X
-// CHECK:STDOUT:   %.loc18_15: X* = address_of %.loc18_17
+// CHECK:STDOUT:   %.loc18_15: X* = addr_of %.loc18_17
 // CHECK:STDOUT:   %q: X* = bind_name q, %.loc18_15
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
diff --git a/toolchain/check/testdata/class/base_field.carbon b/toolchain/check/testdata/class/base_field.carbon
index fe998bf41042..2e2db2f958dc 100644
--- a/toolchain/check/testdata/class/base_field.carbon
+++ b/toolchain/check/testdata/class/base_field.carbon
@@ -83,7 +83,7 @@ fn Access(p: Derived*) -> i32* {
 // CHECK:STDOUT:   %.loc21_15.1: ref Base = class_element_access %.loc21_12, element0
 // CHECK:STDOUT:   %.loc21_15.2: ref Base = converted %.loc21_12, %.loc21_15.1
 // CHECK:STDOUT:   %.loc21_15.3: ref i32 = class_element_access %.loc21_15.2, element2
-// CHECK:STDOUT:   %.loc21_10: i32* = address_of %.loc21_15.3
+// CHECK:STDOUT:   %.loc21_10: i32* = addr_of %.loc21_15.3
 // CHECK:STDOUT:   return %.loc21_10
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/check/testdata/class/base_method.carbon b/toolchain/check/testdata/class/base_method.carbon
index e86402782295..758892a4c3cc 100644
--- a/toolchain/check/testdata/class/base_method.carbon
+++ b/toolchain/check/testdata/class/base_method.carbon
@@ -79,10 +79,10 @@ fn Call(p: Derived*) {
 // CHECK:STDOUT:   %p.ref: Derived* = name_ref p, %p
 // CHECK:STDOUT:   %.loc22_4.1: ref Derived = deref %p.ref
 // CHECK:STDOUT:   %.loc22_7: <bound method> = bound_method %.loc22_4.1, @Base.%F
-// CHECK:STDOUT:   %.loc22_4.2: Derived* = address_of %.loc22_4.1
+// CHECK:STDOUT:   %.loc22_4.2: Derived* = addr_of %.loc22_4.1
 // CHECK:STDOUT:   %.loc22_9.1: ref Derived = deref %.loc22_4.2
 // CHECK:STDOUT:   %.loc22_9.2: ref Base = class_element_access %.loc22_9.1, element0
-// CHECK:STDOUT:   %.loc22_9.3: Base* = address_of %.loc22_9.2
+// CHECK:STDOUT:   %.loc22_9.3: Base* = addr_of %.loc22_9.2
 // CHECK:STDOUT:   %.loc22_9.4: Base* = converted %.loc22_4.2, %.loc22_9.3
 // CHECK:STDOUT:   %.loc22_9.5: init () = call %.loc22_7(%.loc22_9.4)
 // CHECK:STDOUT:   return
diff --git a/toolchain/check/testdata/class/base_method_shadow.carbon b/toolchain/check/testdata/class/base_method_shadow.carbon
index 9b67615c6f5c..9cc67c3dd6aa 100644
--- a/toolchain/check/testdata/class/base_method_shadow.carbon
+++ b/toolchain/check/testdata/class/base_method_shadow.carbon
@@ -108,25 +108,25 @@ fn Call(a: A*, b: B*, c: C*, d: D*) {
 // CHECK:STDOUT:   %a.ref: A* = name_ref a, %a
 // CHECK:STDOUT:   %.loc26_4.1: ref A = deref %a.ref
 // CHECK:STDOUT:   %.loc26_7: <bound method> = bound_method %.loc26_4.1, @A.%F
-// CHECK:STDOUT:   %.loc26_4.2: A* = address_of %.loc26_4.1
+// CHECK:STDOUT:   %.loc26_4.2: A* = addr_of %.loc26_4.1
 // CHECK:STDOUT:   %.loc26_9: init () = call %.loc26_7(%.loc26_4.2)
 // CHECK:STDOUT:   %b.ref: B* = name_ref b, %b
 // CHECK:STDOUT:   %.loc27_4.1: ref B = deref %b.ref
 // CHECK:STDOUT:   %.loc27_7: <bound method> = bound_method %.loc27_4.1, @B.%F
-// CHECK:STDOUT:   %.loc27_4.2: B* = address_of %.loc27_4.1
+// CHECK:STDOUT:   %.loc27_4.2: B* = addr_of %.loc27_4.1
 // CHECK:STDOUT:   %.loc27_9: init () = call %.loc27_7(%.loc27_4.2)
 // CHECK:STDOUT:   %c.ref: C* = name_ref c, %c
 // CHECK:STDOUT:   %.loc28_4.1: ref C = deref %c.ref
 // CHECK:STDOUT:   %.loc28_7: <bound method> = bound_method %.loc28_4.1, @C.%F
-// CHECK:STDOUT:   %.loc28_4.2: C* = address_of %.loc28_4.1
+// CHECK:STDOUT:   %.loc28_4.2: C* = addr_of %.loc28_4.1
 // CHECK:STDOUT:   %.loc28_9: init () = call %.loc28_7(%.loc28_4.2)
 // CHECK:STDOUT:   %d.ref: D* = name_ref d, %d
 // CHECK:STDOUT:   %.loc29_4.1: ref D = deref %d.ref
 // CHECK:STDOUT:   %.loc29_7: <bound method> = bound_method %.loc29_4.1, @B.%F
-// CHECK:STDOUT:   %.loc29_4.2: D* = address_of %.loc29_4.1
+// CHECK:STDOUT:   %.loc29_4.2: D* = addr_of %.loc29_4.1
 // CHECK:STDOUT:   %.loc29_9.1: ref D = deref %.loc29_4.2
 // CHECK:STDOUT:   %.loc29_9.2: ref B = class_element_access %.loc29_9.1, element0
-// CHECK:STDOUT:   %.loc29_9.3: B* = address_of %.loc29_9.2
+// CHECK:STDOUT:   %.loc29_9.3: B* = addr_of %.loc29_9.2
 // CHECK:STDOUT:   %.loc29_9.4: B* = converted %.loc29_4.2, %.loc29_9.3
 // CHECK:STDOUT:   %.loc29_9.5: init () = call %.loc29_7(%.loc29_9.4)
 // CHECK:STDOUT:   return
diff --git a/toolchain/check/testdata/class/derived_to_base.carbon b/toolchain/check/testdata/class/derived_to_base.carbon
index f705cd7391ca..4aa2fe59edb2 100644
--- a/toolchain/check/testdata/class/derived_to_base.carbon
+++ b/toolchain/check/testdata/class/derived_to_base.carbon
@@ -109,7 +109,7 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %p.ref: C* = name_ref p, %p
 // CHECK:STDOUT:   %.loc21_39.1: ref C = deref %p.ref
 // CHECK:STDOUT:   %.loc21_39.2: ref B = class_element_access %.loc21_39.1, element0
-// CHECK:STDOUT:   %.loc21_39.3: B* = address_of %.loc21_39.2
+// CHECK:STDOUT:   %.loc21_39.3: B* = addr_of %.loc21_39.2
 // CHECK:STDOUT:   %.loc21_39.4: B* = converted %p.ref, %.loc21_39.3
 // CHECK:STDOUT:   return %.loc21_39.4
 // CHECK:STDOUT: }
@@ -119,7 +119,7 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %p.ref: B* = name_ref p, %p
 // CHECK:STDOUT:   %.loc22_39.1: ref B = deref %p.ref
 // CHECK:STDOUT:   %.loc22_39.2: ref A = class_element_access %.loc22_39.1, element0
-// CHECK:STDOUT:   %.loc22_39.3: A* = address_of %.loc22_39.2
+// CHECK:STDOUT:   %.loc22_39.3: A* = addr_of %.loc22_39.2
 // CHECK:STDOUT:   %.loc22_39.4: A* = converted %p.ref, %.loc22_39.3
 // CHECK:STDOUT:   return %.loc22_39.4
 // CHECK:STDOUT: }
@@ -130,7 +130,7 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %.loc23_39.1: ref C = deref %p.ref
 // CHECK:STDOUT:   %.loc23_39.2: ref B = class_element_access %.loc23_39.1, element0
 // CHECK:STDOUT:   %.loc23_39.3: ref A = class_element_access %.loc23_39.2, element0
-// CHECK:STDOUT:   %.loc23_39.4: A* = address_of %.loc23_39.3
+// CHECK:STDOUT:   %.loc23_39.4: A* = addr_of %.loc23_39.3
 // CHECK:STDOUT:   %.loc23_39.5: A* = converted %p.ref, %.loc23_39.4
 // CHECK:STDOUT:   return %.loc23_39.5
 // CHECK:STDOUT: }
@@ -155,7 +155,7 @@ fn ConvertInit() {
 // CHECK:STDOUT:   %.loc30_15.1: ref B = class_element_access %.loc30_12, element0
 // CHECK:STDOUT:   %.loc30_15.2: ref A = class_element_access %.loc30_15.1, element0
 // CHECK:STDOUT:   %.loc30_15.3: ref A = converted %.loc30_12, %.loc30_15.2
-// CHECK:STDOUT:   %.loc30_10: A* = address_of %.loc30_15.3
+// CHECK:STDOUT:   %.loc30_10: A* = addr_of %.loc30_15.3
 // CHECK:STDOUT:   return %.loc30_10
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/check/testdata/class/fail_addr_self.carbon b/toolchain/check/testdata/class/fail_addr_self.carbon
index d1f590713d85..4326350cef12 100644
--- a/toolchain/check/testdata/class/fail_addr_self.carbon
+++ b/toolchain/check/testdata/class/fail_addr_self.carbon
@@ -77,12 +77,12 @@ fn F(c: Class, p: Class*) {
 // CHECK:STDOUT:   %p.ref.loc30: Class* = name_ref p, %p
 // CHECK:STDOUT:   %.loc30_4.1: ref Class = deref %p.ref.loc30
 // CHECK:STDOUT:   %.loc30_7: <bound method> = bound_method %.loc30_4.1, @Class.%F
-// CHECK:STDOUT:   %.loc30_4.2: Class* = address_of %.loc30_4.1
+// CHECK:STDOUT:   %.loc30_4.2: Class* = addr_of %.loc30_4.1
 // CHECK:STDOUT:   %.loc30_9: init () = call %.loc30_7(%.loc30_4.2)
 // CHECK:STDOUT:   %p.ref.loc38: Class* = name_ref p, %p
 // CHECK:STDOUT:   %.loc38_4.1: ref Class = deref %p.ref.loc38
 // CHECK:STDOUT:   %.loc38_7: <bound method> = bound_method %.loc38_4.1, @Class.%G
-// CHECK:STDOUT:   %.loc38_4.2: Class* = address_of %.loc38_4.1
+// CHECK:STDOUT:   %.loc38_4.2: Class* = addr_of %.loc38_4.1
 // CHECK:STDOUT:   %.loc38_9: init () = call %.loc38_7(<invalid>)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
diff --git a/toolchain/check/testdata/class/fail_base_bad_type.carbon b/toolchain/check/testdata/class/fail_base_bad_type.carbon
index 41aee7ce2c2c..a7320166ef4f 100644
--- a/toolchain/check/testdata/class/fail_base_bad_type.carbon
+++ b/toolchain/check/testdata/class/fail_base_bad_type.carbon
@@ -337,7 +337,7 @@ fn AccessMemberWithInvalidBaseFinal_NoMember(p: DeriveFromFinal*) -> i32 {
 // CHECK:STDOUT:   %p.ref: DeriveFromFinal* = name_ref p, %p
 // CHECK:STDOUT:   %.loc106_11.1: ref DeriveFromFinal = deref %p.ref
 // CHECK:STDOUT:   %.loc106_11.2: ref Final = class_element_access %.loc106_11.1, element0
-// CHECK:STDOUT:   %.loc106_11.3: Final* = address_of %.loc106_11.2
+// CHECK:STDOUT:   %.loc106_11.3: Final* = addr_of %.loc106_11.2
 // CHECK:STDOUT:   %.loc106_11.4: Final* = converted %p.ref, %.loc106_11.3
 // CHECK:STDOUT:   return %.loc106_11.4
 // CHECK:STDOUT: }
diff --git a/toolchain/check/testdata/class/fail_init_as_inplace.carbon b/toolchain/check/testdata/class/fail_init_as_inplace.carbon
index 05f1c2cd9cbf..1ff18be2970f 100644
--- a/toolchain/check/testdata/class/fail_init_as_inplace.carbon
+++ b/toolchain/check/testdata/class/fail_init_as_inplace.carbon
@@ -74,7 +74,7 @@ fn F() {
 // CHECK:STDOUT:   assign %c.var, <error>
 // CHECK:STDOUT:   %G.ref: <function> = name_ref G, file.%G
 // CHECK:STDOUT:   %c.ref: ref Class = name_ref c, %c
-// CHECK:STDOUT:   %.loc22_5: Class* = address_of %c.ref
+// CHECK:STDOUT:   %.loc22_5: Class* = addr_of %c.ref
 // CHECK:STDOUT:   %.loc22_4: init () = call %G.ref(%.loc22_5)
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
diff --git a/toolchain/check/testdata/class/method.carbon b/toolchain/check/testdata/class/method.carbon
index 63d19814db96..c994dad4fb73 100644
--- a/toolchain/check/testdata/class/method.carbon
+++ b/toolchain/check/testdata/class/method.carbon
@@ -105,7 +105,7 @@ fn CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT:   %c: ref Class = bind_name c, %c.var
 // CHECK:STDOUT:   %c.ref: ref Class = name_ref c, %c
 // CHECK:STDOUT:   %.loc26_11: <bound method> = bound_method %c.ref, @Class.%G
-// CHECK:STDOUT:   %.loc26_10: Class* = address_of %c.ref
+// CHECK:STDOUT:   %.loc26_10: Class* = addr_of %c.ref
 // CHECK:STDOUT:   %.loc26_13: init i32 = call %.loc26_11(%.loc26_10)
 // CHECK:STDOUT:   %.loc26_15.1: i32 = value_of_initializer %.loc26_13
 // CHECK:STDOUT:   %.loc26_15.2: i32 = converted %.loc26_13, %.loc26_15.1
@@ -129,7 +129,7 @@ fn CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT:   %p.ref: Class* = name_ref p, %p
 // CHECK:STDOUT:   %.loc34_11.1: ref Class = deref %p.ref
 // CHECK:STDOUT:   %.loc34_14: <bound method> = bound_method %.loc34_11.1, @Class.%G
-// CHECK:STDOUT:   %.loc34_11.2: Class* = address_of %.loc34_11.1
+// CHECK:STDOUT:   %.loc34_11.2: Class* = addr_of %.loc34_11.1
 // CHECK:STDOUT:   %.loc34_16: init i32 = call %.loc34_14(%.loc34_11.2)
 // CHECK:STDOUT:   %.loc34_18.1: i32 = value_of_initializer %.loc34_16
 // CHECK:STDOUT:   %.loc34_18.2: i32 = converted %.loc34_16, %.loc34_18.1
@@ -159,7 +159,7 @@ fn CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT:   %.loc44_14.2: init Class = call %Make.ref() to %.loc44_14.1
 // CHECK:STDOUT:   %.loc44_14.3: ref Class = temporary %.loc44_14.1, %.loc44_14.2
 // CHECK:STDOUT:   %.loc44_16: <bound method> = bound_method %.loc44_14.3, @Class.%G
-// CHECK:STDOUT:   %.loc44_14.4: Class* = address_of %.loc44_14.3
+// CHECK:STDOUT:   %.loc44_14.4: Class* = addr_of %.loc44_14.3
 // CHECK:STDOUT:   %.loc44_18: init i32 = call %.loc44_16(%.loc44_14.4)
 // CHECK:STDOUT:   %.loc44_20.1: i32 = value_of_initializer %.loc44_18
 // CHECK:STDOUT:   %.loc44_20.2: i32 = converted %.loc44_18, %.loc44_20.1
diff --git a/toolchain/check/testdata/class/self_conversion.carbon b/toolchain/check/testdata/class/self_conversion.carbon
index 35974640e462..ea8c131f8f9a 100644
--- a/toolchain/check/testdata/class/self_conversion.carbon
+++ b/toolchain/check/testdata/class/self_conversion.carbon
@@ -96,10 +96,10 @@ fn Call(p: Derived*) -> i32 {
 // CHECK:STDOUT:   %p.ref.loc27: Derived* = name_ref p, %p
 // CHECK:STDOUT:   %.loc27_4.1: ref Derived = deref %p.ref.loc27
 // CHECK:STDOUT:   %.loc27_7: <bound method> = bound_method %.loc27_4.1, @Derived.%AddrSelfBase
-// CHECK:STDOUT:   %.loc27_4.2: Derived* = address_of %.loc27_4.1
+// CHECK:STDOUT:   %.loc27_4.2: Derived* = addr_of %.loc27_4.1
 // CHECK:STDOUT:   %.loc27_20.1: ref Derived = deref %.loc27_4.2
 // CHECK:STDOUT:   %.loc27_20.2: ref Base = class_element_access %.loc27_20.1, element0
-// CHECK:STDOUT:   %.loc27_20.3: Base* = address_of %.loc27_20.2
+// CHECK:STDOUT:   %.loc27_20.3: Base* = addr_of %.loc27_20.2
 // CHECK:STDOUT:   %.loc27_20.4: Base* = converted %.loc27_4.2, %.loc27_20.3
 // CHECK:STDOUT:   %.loc27_20.5: init () = call %.loc27_7(%.loc27_20.4)
 // CHECK:STDOUT:   %p.ref.loc28: Derived* = name_ref p, %p
diff --git a/toolchain/check/testdata/index/expr_category.carbon b/toolchain/check/testdata/index/expr_category.carbon
index 71284a0f2c8d..1e8bad35d404 100644
--- a/toolchain/check/testdata/index/expr_category.carbon
+++ b/toolchain/check/testdata/index/expr_category.carbon
@@ -68,7 +68,7 @@ fn ValueBinding(b: [i32; 3]) {
 // CHECK:STDOUT:   %a.ref.loc13: ref [i32; 3] = name_ref 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:   %.loc13_18: i32* = addr_of %.loc13_22
 // CHECK:STDOUT:   assign %pa.var, %.loc13_18
 // CHECK:STDOUT:   %a.ref.loc14: ref [i32; 3] = name_ref a, %a
 // CHECK:STDOUT:   %.loc14_5: i32 = int_literal 0
diff --git a/toolchain/check/testdata/index/fail_expr_category.carbon b/toolchain/check/testdata/index/fail_expr_category.carbon
index c067e77375c0..5c1f96e71747 100644
--- a/toolchain/check/testdata/index/fail_expr_category.carbon
+++ b/toolchain/check/testdata/index/fail_expr_category.carbon
@@ -53,7 +53,7 @@ fn G(b: [i32; 3]) {
 // CHECK:STDOUT:   %.loc14_22.1: ref [i32; 3] = value_as_ref %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:   %.loc14_18: i32* = addr_of %.loc14_22.3
 // CHECK:STDOUT:   assign %pb.var, %.loc14_18
 // CHECK:STDOUT:   %b.ref.loc18: [i32; 3] = name_ref b, %b
 // CHECK:STDOUT:   %.loc18_5: i32 = int_literal 0
@@ -72,7 +72,7 @@ fn G(b: [i32; 3]) {
 // CHECK:STDOUT:   %.loc25_20.3: ref [i32; 3] = temporary %.loc25_20.1, %.loc25_20.2
 // 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:   %.loc25_18: i32* = addr_of %.loc25_24.2
 // CHECK:STDOUT:   assign %pf.var, %.loc25_18
 // CHECK:STDOUT:   %F.ref.loc29: <function> = name_ref F, file.%F
 // CHECK:STDOUT:   %.loc29_4.1: ref [i32; 3] = temporary_storage
diff --git a/toolchain/check/testdata/operators/assignment.carbon b/toolchain/check/testdata/operators/assignment.carbon
index 71255eb0a6fa..2738f08cb4ec 100644
--- a/toolchain/check/testdata/operators/assignment.carbon
+++ b/toolchain/check/testdata/operators/assignment.carbon
@@ -94,7 +94,7 @@ fn Main() {
 // 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_ref a, %a
-// CHECK:STDOUT:   %.loc19_17: i32* = address_of %a.ref.loc19
+// CHECK:STDOUT:   %.loc19_17: i32* = addr_of %a.ref.loc19
 // CHECK:STDOUT:   assign %p.var, %.loc19_17
 // CHECK:STDOUT:   %p.ref.loc20: ref i32* = name_ref p, %p
 // CHECK:STDOUT:   %.loc20_4: i32* = bind_value %p.ref.loc20
@@ -111,7 +111,7 @@ fn Main() {
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.else:
 // CHECK:STDOUT:   %a.ref.loc22: ref i32 = name_ref a, %a
-// CHECK:STDOUT:   %.loc22_25: i32* = address_of %a.ref.loc22
+// CHECK:STDOUT:   %.loc22_25: i32* = addr_of %a.ref.loc22
 // CHECK:STDOUT:   br !if.expr.result(%.loc22_25)
 // CHECK:STDOUT:
 // CHECK:STDOUT: !if.expr.result:
diff --git a/toolchain/check/testdata/pointer/address_of_deref.carbon b/toolchain/check/testdata/pointer/address_of_deref.carbon
index 14fb769ce166..7227a9c498ad 100644
--- a/toolchain/check/testdata/pointer/address_of_deref.carbon
+++ b/toolchain/check/testdata/pointer/address_of_deref.carbon
@@ -27,9 +27,9 @@ fn F() -> i32 {
 // CHECK:STDOUT:   %.loc8: i32 = int_literal 0
 // CHECK:STDOUT:   assign %n.var, %.loc8
 // CHECK:STDOUT:   %n.ref: ref i32 = name_ref n, %n
-// CHECK:STDOUT:   %.loc9_13: i32* = address_of %n.ref
+// CHECK:STDOUT:   %.loc9_13: i32* = addr_of %n.ref
 // CHECK:STDOUT:   %.loc9_12: ref i32 = deref %.loc9_13
-// CHECK:STDOUT:   %.loc9_11: i32* = address_of %.loc9_12
+// CHECK:STDOUT:   %.loc9_11: i32* = addr_of %.loc9_12
 // CHECK:STDOUT:   %.loc9_10.1: ref i32 = deref %.loc9_11
 // CHECK:STDOUT:   %.loc9_10.2: i32 = bind_value %.loc9_10.1
 // CHECK:STDOUT:   return %.loc9_10.2
diff --git a/toolchain/check/testdata/pointer/address_of_lvalue.carbon b/toolchain/check/testdata/pointer/address_of_lvalue.carbon
index 6482df2dec09..e54b37237d46 100644
--- a/toolchain/check/testdata/pointer/address_of_lvalue.carbon
+++ b/toolchain/check/testdata/pointer/address_of_lvalue.carbon
@@ -50,21 +50,21 @@ fn F() {
 // 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_ref s, %s
-// CHECK:STDOUT:   %.loc10_32: {.a: i32, .b: i32}* = address_of %s.ref.loc10
+// CHECK:STDOUT:   %.loc10_32: {.a: i32, .b: i32}* = addr_of %s.ref.loc10
 // CHECK:STDOUT:   assign %p.var, %.loc10_32
 // CHECK:STDOUT:   %.loc11_13: type = ptr_type i32
 // 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_ref s, %s
 // CHECK:STDOUT:   %.loc11_19: ref i32 = struct_access %s.ref.loc11, element0
-// CHECK:STDOUT:   %.loc11_17: i32* = address_of %.loc11_19
+// CHECK:STDOUT:   %.loc11_17: i32* = addr_of %.loc11_19
 // CHECK:STDOUT:   assign %q.var, %.loc11_17
 // CHECK:STDOUT:   %.loc12_13: type = ptr_type i32
 // 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_ref s, %s
 // CHECK:STDOUT:   %.loc12_19: ref i32 = struct_access %s.ref.loc12, element1
-// CHECK:STDOUT:   %.loc12_17: i32* = address_of %.loc12_19
+// CHECK:STDOUT:   %.loc12_17: i32* = addr_of %.loc12_19
 // CHECK:STDOUT:   assign %r.var, %.loc12_17
 // CHECK:STDOUT:   %.loc14_19.1: (type, type) = tuple_literal (i32, i32)
 // CHECK:STDOUT:   %.loc14_19.2: type = converted %.loc14_19.1, constants.%.loc14_19.2
@@ -86,7 +86,7 @@ fn F() {
 // CHECK:STDOUT:   %t.ref.loc15: ref (i32, i32) = name_ref 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:   %.loc15_18: i32* = addr_of %.loc15_22
 // CHECK:STDOUT:   assign %t0.var, %.loc15_18
 // CHECK:STDOUT:   %.loc16_14: type = ptr_type i32
 // CHECK:STDOUT:   %t1.var: ref i32* = var t1
@@ -94,7 +94,7 @@ fn F() {
 // CHECK:STDOUT:   %t.ref.loc16: ref (i32, i32) = name_ref 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:   %.loc16_18: i32* = addr_of %.loc16_22
 // 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 67cf379838d8..31f9cf35b42c 100644
--- a/toolchain/check/testdata/pointer/basic.carbon
+++ b/toolchain/check/testdata/pointer/basic.carbon
@@ -28,7 +28,7 @@ fn F() -> i32 {
 // 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_ref n, %n
-// CHECK:STDOUT:   %.loc9_17: i32* = address_of %n.ref
+// CHECK:STDOUT:   %.loc9_17: i32* = addr_of %n.ref
 // CHECK:STDOUT:   assign %p.var, %.loc9_17
 // CHECK:STDOUT:   %p.ref: ref i32* = name_ref p, %p
 // CHECK:STDOUT:   %.loc11_11: i32* = bind_value %p.ref
diff --git a/toolchain/check/testdata/pointer/fail_address_of_error.carbon b/toolchain/check/testdata/pointer/fail_address_of_error.carbon
index 94599c40d2db..15e298a3f99b 100644
--- a/toolchain/check/testdata/pointer/fail_address_of_error.carbon
+++ b/toolchain/check/testdata/pointer/fail_address_of_error.carbon
@@ -33,10 +33,10 @@ fn Test() {
 // CHECK:STDOUT: fn @Test() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %undeclared.ref.loc11: <error> = name_ref undeclared, <error>
-// CHECK:STDOUT:   %.loc11: <error>* = address_of %undeclared.ref.loc11
+// CHECK:STDOUT:   %.loc11: <error>* = addr_of %undeclared.ref.loc11
 // CHECK:STDOUT:   %undeclared.ref.loc18: <error> = name_ref undeclared, <error>
-// CHECK:STDOUT:   %.loc18_5: <error>* = address_of %undeclared.ref.loc18
-// CHECK:STDOUT:   %.loc18_3: <error>** = address_of %.loc18_5
+// CHECK:STDOUT:   %.loc18_5: <error>* = addr_of %undeclared.ref.loc18
+// CHECK:STDOUT:   %.loc18_3: <error>** = addr_of %.loc18_5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/check/testdata/pointer/fail_address_of_value.carbon b/toolchain/check/testdata/pointer/fail_address_of_value.carbon
index c17774983398..731455544d2f 100644
--- a/toolchain/check/testdata/pointer/fail_address_of_value.carbon
+++ b/toolchain/check/testdata/pointer/fail_address_of_value.carbon
@@ -114,20 +114,20 @@ fn AddressOfParam(param: i32) {
 // CHECK:STDOUT: fn @AddressOfLiteral() {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %.loc15_4: i32 = int_literal 0
-// CHECK:STDOUT:   %.loc15_3: i32* = address_of %.loc15_4
+// CHECK:STDOUT:   %.loc15_3: i32* = addr_of %.loc15_4
 // CHECK:STDOUT:   %.loc19_4: bool = bool_literal true
-// CHECK:STDOUT:   %.loc19_3: bool* = address_of %.loc19_4
+// CHECK:STDOUT:   %.loc19_3: bool* = addr_of %.loc19_4
 // CHECK:STDOUT:   %.loc23_4: f64 = real_literal 10e-1
-// CHECK:STDOUT:   %.loc23_3: f64* = address_of %.loc23_4
+// CHECK:STDOUT:   %.loc23_3: f64* = addr_of %.loc23_4
 // CHECK:STDOUT:   %.loc27_4: String = string_literal "Hello"
-// CHECK:STDOUT:   %.loc27_3: String* = address_of %.loc27_4
+// CHECK:STDOUT:   %.loc27_3: String* = addr_of %.loc27_4
 // CHECK:STDOUT:   %.loc31_5: i32 = int_literal 1
 // CHECK:STDOUT:   %.loc31_8: i32 = int_literal 2
 // CHECK:STDOUT:   %.loc31_9: (i32, i32) = tuple_literal (%.loc31_5, %.loc31_8)
-// CHECK:STDOUT:   %.loc31_3: (i32, i32)* = address_of %.loc31_9
+// CHECK:STDOUT:   %.loc31_3: (i32, i32)* = addr_of %.loc31_9
 // CHECK:STDOUT:   %.loc35_10: i32 = int_literal 5
 // CHECK:STDOUT:   %.loc35_11: {.a: i32} = struct_literal (%.loc35_10)
-// CHECK:STDOUT:   %.loc35_3: {.a: i32}* = address_of %.loc35_11
+// CHECK:STDOUT:   %.loc35_3: {.a: i32}* = addr_of %.loc35_11
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -143,16 +143,16 @@ fn AddressOfParam(param: i32) {
 // CHECK:STDOUT:
 // CHECK:STDOUT: !and.result:
 // CHECK:STDOUT:   %.loc42_10.2: bool = block_arg !and.result
-// CHECK:STDOUT:   %.loc42_3: bool* = address_of %.loc42_10.2
+// CHECK:STDOUT:   %.loc42_3: bool* = addr_of %.loc42_10.2
 // CHECK:STDOUT:   %H.ref: <function> = name_ref H, file.%H
 // CHECK:STDOUT:   %.loc46_5.1: init {.a: i32} = call %H.ref()
 // CHECK:STDOUT:   %.loc46_5.2: ref {.a: i32} = temporary_storage
 // CHECK:STDOUT:   %.loc46_5.3: ref {.a: i32} = temporary %.loc46_5.2, %.loc46_5.1
 // CHECK:STDOUT:   %.loc46_7: ref i32 = struct_access %.loc46_5.3, element0
-// CHECK:STDOUT:   %.loc46_3: i32* = address_of %.loc46_7
+// CHECK:STDOUT:   %.loc46_3: i32* = addr_of %.loc46_7
 // CHECK:STDOUT:   %.loc50_9: bool = bool_literal true
 // CHECK:STDOUT:   %.loc50_5: bool = not %.loc50_9
-// CHECK:STDOUT:   %.loc50_3: bool* = address_of %.loc50_5
+// CHECK:STDOUT:   %.loc50_3: bool* = addr_of %.loc50_5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -160,16 +160,16 @@ fn AddressOfParam(param: i32) {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %G.ref: <function> = name_ref G, file.%G
 // CHECK:STDOUT:   %.loc57_5: init i32 = call %G.ref()
-// CHECK:STDOUT:   %.loc57_3: i32* = address_of %.loc57_5
+// CHECK:STDOUT:   %.loc57_3: i32* = addr_of %.loc57_5
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @AddressOfType() {
 // CHECK:STDOUT: !entry:
-// CHECK:STDOUT:   %.loc64: type* = address_of i32
+// CHECK:STDOUT:   %.loc64: type* = addr_of i32
 // CHECK:STDOUT:   %.loc68_5: type = const_type i32
 // CHECK:STDOUT:   %.loc68_14: type = ptr_type const i32
-// CHECK:STDOUT:   %.loc68_3: type* = address_of %.loc68_14
+// CHECK:STDOUT:   %.loc68_3: type* = addr_of %.loc68_14
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -182,7 +182,7 @@ fn AddressOfParam(param: i32) {
 // CHECK:STDOUT:   %.loc75_10.2: (i32, i32) = tuple_value (%.loc75_6, %.loc75_9)
 // CHECK:STDOUT:   %.loc75_10.3: (i32, i32) = converted %.loc75_10.1, %.loc75_10.2
 // CHECK:STDOUT:   %.loc75_13: i32 = tuple_index %.loc75_10.3, %.loc75_12
-// CHECK:STDOUT:   %.loc75_3: i32* = address_of %.loc75_13
+// CHECK:STDOUT:   %.loc75_3: i32* = addr_of %.loc75_13
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
@@ -192,7 +192,7 @@ fn AddressOfParam(param: i32) {
 // 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_ref param, %param
-// CHECK:STDOUT:   %.loc82_26: i32* = address_of %param.ref
+// CHECK:STDOUT:   %.loc82_26: i32* = addr_of %param.ref
 // CHECK:STDOUT:   assign %param_addr.var, %.loc82_26
 // CHECK:STDOUT:   return
 // CHECK:STDOUT: }
diff --git a/toolchain/check/testdata/struct/fail_nested_incomplete.carbon b/toolchain/check/testdata/struct/fail_nested_incomplete.carbon
index c38186e2fef8..843de739e5ac 100644
--- a/toolchain/check/testdata/struct/fail_nested_incomplete.carbon
+++ b/toolchain/check/testdata/struct/fail_nested_incomplete.carbon
@@ -38,7 +38,7 @@ var p: Incomplete* = &s.a;
 // CHECK:STDOUT:   %p.var: ref Incomplete* = var p
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
 // CHECK:STDOUT:   %s.ref: ref <error> = name_ref s, %s
-// CHECK:STDOUT:   %.loc20_22: <error>* = address_of <error>
+// CHECK:STDOUT:   %.loc20_22: <error>* = addr_of <error>
 // CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon b/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon
index 35cd5337976c..149f126b00a3 100644
--- a/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon
+++ b/toolchain/check/testdata/tuples/fail_nested_incomplete.carbon
@@ -42,7 +42,7 @@ var p: Incomplete* = &t[1];
 // CHECK:STDOUT:   %p: ref Incomplete* = bind_name p, %p.var
 // CHECK:STDOUT:   %t.ref: ref <error> = name_ref t, %t
 // CHECK:STDOUT:   %.loc20_25: i32 = int_literal 1
-// CHECK:STDOUT:   %.loc20_22: <error>* = address_of <error>
+// CHECK:STDOUT:   %.loc20_22: <error>* = addr_of <error>
 // CHECK:STDOUT:   assign %p.var, <error>
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
diff --git a/toolchain/diagnostics/diagnostic_kind.def b/toolchain/diagnostics/diagnostic_kind.def
index 90adca974078..db7b44d282df 100644
--- a/toolchain/diagnostics/diagnostic_kind.def
+++ b/toolchain/diagnostics/diagnostic_kind.def
@@ -161,8 +161,8 @@ CARBON_DIAGNOSTIC_KIND(ConstructionOfAbstractClass)
 CARBON_DIAGNOSTIC_KIND(InterfacePreviousDefinition)
 CARBON_DIAGNOSTIC_KIND(InterfaceRedefinition)
 
-CARBON_DIAGNOSTIC_KIND(AddressOfEphemeralRef)
-CARBON_DIAGNOSTIC_KIND(AddressOfNonRef)
+CARBON_DIAGNOSTIC_KIND(AddrOfEphemeralRef)
+CARBON_DIAGNOSTIC_KIND(AddrOfNonRef)
 CARBON_DIAGNOSTIC_KIND(AddrOnNonSelfParam)
 CARBON_DIAGNOSTIC_KIND(ArrayInitFromLiteralArgCountMismatch)
 CARBON_DIAGNOSTIC_KIND(ArrayInitFromExprArgCountMismatch)
diff --git a/toolchain/lower/handle.cpp b/toolchain/lower/handle.cpp
index e8e0cde47252..ddad56c68358 100644
--- a/toolchain/lower/handle.cpp
+++ b/toolchain/lower/handle.cpp
@@ -25,8 +25,8 @@ static auto FatalErrorIfEncountered(InstT inst) -> void {
       << inst;
 }
 
-auto HandleAddressOf(FunctionContext& context, SemIR::InstId inst_id,
-                     SemIR::AddressOf inst) -> void {
+auto HandleAddrOf(FunctionContext& context, SemIR::InstId inst_id,
+                  SemIR::AddrOf inst) -> void {
   context.SetLocal(inst_id, context.GetValue(inst.lvalue_id));
 }
 
diff --git a/toolchain/parse/handle_binding_pattern.cpp b/toolchain/parse/handle_binding_pattern.cpp
index c6860919fc22..62c15c8c695d 100644
--- a/toolchain/parse/handle_binding_pattern.cpp
+++ b/toolchain/parse/handle_binding_pattern.cpp
@@ -18,7 +18,7 @@ auto HandleBindingPattern(Context& context) -> void {
   }
 
   if (auto token = context.ConsumeIf(Lex::TokenKind::Addr)) {
-    context.PushState({.state = State::BindingPatternAddress,
+    context.PushState({.state = State::BindingPatternAddr,
                        .token = *token,
                        .subtree_start = state.subtree_start});
   }
@@ -92,10 +92,10 @@ auto HandleBindingPatternFinishAsRegular(Context& context) -> void {
   HandleBindingPatternFinish(context, NodeKind::BindingPattern);
 }
 
-auto HandleBindingPatternAddress(Context& context) -> void {
+auto HandleBindingPatternAddr(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::Address, state.token, state.subtree_start,
+  context.AddNode(NodeKind::Addr, state.token, state.subtree_start,
                   state.has_error);
 
   // If an error was encountered, propagate it while adding a node.
diff --git a/toolchain/parse/node_kind.def b/toolchain/parse/node_kind.def
index 1252c3ca40f1..facb3023e015 100644
--- a/toolchain/parse/node_kind.def
+++ b/toolchain/parse/node_kind.def
@@ -296,13 +296,13 @@ CARBON_PARSE_NODE_KIND_BRACKET(ArrayExpr, ArrayExprSemi, CloseSquareBracket)
 //       IdentifierName or SelfValueName
 //       _external_: type expression
 //     [Generic]BindingPattern
-//   _optional_ Address
+//   _optional_ Addr
 // _optional_ Template
 //
 // TODO: Rename GenericBindingPattern to CompileTimeBindingPattern.
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(BindingPattern, 2, CARBON_IF_VALID(Colon))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(GenericBindingPattern, 2, ColonExclaim)
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(Address, 1, Addr)
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(Addr, 1, Addr)
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(Template, 1, Template)
 
 // `let`:
diff --git a/toolchain/parse/state.def b/toolchain/parse/state.def
index d07be0eb1870..ba455560eeca 100644
--- a/toolchain/parse/state.def
+++ b/toolchain/parse/state.def
@@ -832,7 +832,7 @@ CARBON_PARSE_STATE(Pattern)
 //
 // addr        (variant is not Variable)
 // ^~~~
-//   3. BindingPatternAddress
+//   3. BindingPatternAddr
 //
 // THEN
 //
@@ -860,7 +860,7 @@ CARBON_PARSE_STATE(BindingPattern)
 // addr name: type
 //                ^
 //   (state done)
-CARBON_PARSE_STATE(BindingPatternAddress)
+CARBON_PARSE_STATE(BindingPatternAddr)
 
 // Handles `template` in a binding pattern.
 //
diff --git a/toolchain/parse/testdata/class/fn_definitions.carbon b/toolchain/parse/testdata/class/fn_definitions.carbon
index e1647790c0d6..96ffcc67ec3f 100644
--- a/toolchain/parse/testdata/class/fn_definitions.carbon
+++ b/toolchain/parse/testdata/class/fn_definitions.carbon
@@ -59,7 +59,7 @@ class Foo {
 // CHECK:STDOUT:                   {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:                 {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'BindingPattern', text: ':', subtree_size: 4},
-// CHECK:STDOUT:             {kind: 'Address', text: 'addr', subtree_size: 5},
+// CHECK:STDOUT:             {kind: 'Addr', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
 // CHECK:STDOUT:             {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:           {kind: 'TuplePattern', text: ')', subtree_size: 2},
diff --git a/toolchain/parse/testdata/function/declaration/addr.carbon b/toolchain/parse/testdata/function/declaration/addr.carbon
index d3683525c472..886c17377b53 100644
--- a/toolchain/parse/testdata/function/declaration/addr.carbon
+++ b/toolchain/parse/testdata/function/declaration/addr.carbon
@@ -16,7 +16,7 @@ fn foo(addr a: i32*);
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BindingPattern', text: ':', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'Address', text: 'addr', subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'Addr', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'TuplePattern', text: ')', subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'FunctionDecl', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/generics/generic_params/template_addr.carbon b/toolchain/parse/testdata/generics/generic_params/template_addr.carbon
index f5ca89c2568a..3de430194e9f 100644
--- a/toolchain/parse/testdata/generics/generic_params/template_addr.carbon
+++ b/toolchain/parse/testdata/generics/generic_params/template_addr.carbon
@@ -15,7 +15,7 @@ fn foo(template addr a:! i32);
 // CHECK:STDOUT:               {kind: 'IdentifierName', text: 'a'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'GenericBindingPattern', text: ':!', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'Addr', text: 'addr', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'Template', text: 'template', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'TuplePattern', text: ')', subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'FunctionDecl', text: ';', subtree_size: 10},
diff --git a/toolchain/parse/testdata/generics/interface/self_pointer.carbon b/toolchain/parse/testdata/generics/interface/self_pointer.carbon
index dd4cb2e640a5..9ff0a2bc54b9 100644
--- a/toolchain/parse/testdata/generics/interface/self_pointer.carbon
+++ b/toolchain/parse/testdata/generics/interface/self_pointer.carbon
@@ -22,7 +22,7 @@ interface Foo {
 // CHECK:STDOUT:                 {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'BindingPattern', text: ':', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'Addr', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'b'},
@@ -39,7 +39,7 @@ interface Foo {
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'foo'},
 // CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'BindingPattern', text: ':', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'Addr', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'b'},
diff --git a/toolchain/parse/typed_nodes.h b/toolchain/parse/typed_nodes.h
index 5a099818376e..81e4cb00c196 100644
--- a/toolchain/parse/typed_nodes.h
+++ b/toolchain/parse/typed_nodes.h
@@ -233,8 +233,8 @@ struct GenericBindingPattern {
 };
 
 // An address-of binding: `addr self: Self*`.
-struct Address {
-  static constexpr auto Kind = NodeKind::Address.Define(NodeCategory::Pattern);
+struct Addr {
+  static constexpr auto Kind = NodeKind::Addr.Define(NodeCategory::Pattern);
 
   AnyPatternId inner;
 };
diff --git a/toolchain/sem_ir/file.cpp b/toolchain/sem_ir/file.cpp
index f08ea22d9e6d..6050aedce1e3 100644
--- a/toolchain/sem_ir/file.cpp
+++ b/toolchain/sem_ir/file.cpp
@@ -197,7 +197,7 @@ static auto GetTypePrecedence(InstKind kind) -> int {
       // now, all cross-references refer to builtin types from the prelude.
       return 0;
 
-    case AddressOf::Kind:
+    case AddrOf::Kind:
     case AddrPattern::Kind:
     case ArrayIndex::Kind:
     case ArrayInit::Kind:
@@ -402,7 +402,7 @@ auto File::StringifyTypeExpr(InstId outer_inst_id) const -> std::string {
         }
         break;
       }
-      case AddressOf::Kind:
+      case AddrOf::Kind:
       case AddrPattern::Kind:
       case ArrayIndex::Kind:
       case ArrayInit::Kind:
@@ -512,7 +512,7 @@ auto GetExprCategory(const File& file, InstId inst_id) -> ExprCategory {
         continue;
       }
 
-      case AddressOf::Kind:
+      case AddrOf::Kind:
       case AddrPattern::Kind:
       case ArrayType::Kind:
       case BindSymbolicName::Kind:
diff --git a/toolchain/sem_ir/inst_kind.def b/toolchain/sem_ir/inst_kind.def
index 3a7c3e7da2b5..e5f6738d1295 100644
--- a/toolchain/sem_ir/inst_kind.def
+++ b/toolchain/sem_ir/inst_kind.def
@@ -17,7 +17,7 @@
 
 // For each instruction kind declared here there is a matching definition in
 // `typed_insts.h`.
-CARBON_SEM_IR_INST_KIND(AddressOf)
+CARBON_SEM_IR_INST_KIND(AddrOf)
 CARBON_SEM_IR_INST_KIND(AddrPattern)
 CARBON_SEM_IR_INST_KIND(ArrayIndex)
 CARBON_SEM_IR_INST_KIND(ArrayInit)
diff --git a/toolchain/sem_ir/typed_insts.h b/toolchain/sem_ir/typed_insts.h
index 4537771a914f..6285c0d60140 100644
--- a/toolchain/sem_ir/typed_insts.h
+++ b/toolchain/sem_ir/typed_insts.h
@@ -50,8 +50,8 @@
 
 namespace Carbon::SemIR {
 
-struct AddressOf {
-  static constexpr auto Kind = InstKind::AddressOf.Define("address_of");
+struct AddrOf {
+  static constexpr auto Kind = InstKind::AddrOf.Define("addr_of");
 
   // TODO: Make this more specific.
   Parse::NodeId parse_node;
@@ -62,7 +62,7 @@ struct AddressOf {
 struct AddrPattern {
   static constexpr auto Kind = InstKind::AddrPattern.Define("addr_pattern");
 
-  Parse::AddressId parse_node;
+  Parse::AddrId parse_node;
   TypeId type_id;
   // The `self` binding.
   InstId inner_id;