Use abbreviation "expr" instead of "expression" (#3375)

Part of switching to the [abbreviations we've decided to
use](https://docs.google.com/document/d/1RRYMm42osyqhI2LyjrjockYCutQ5dOf8Abu50kTrkX0/edit?resourcekey=0-kHyqOESbOHmzZphUbtLrTw#heading=h.pph7i5m5un7q).

I will rename files in a follow-up PR.

toolchain/check/context.cpp

@@ -424,12 +424,12 @@ auto Context::is_current_position_reachable() -> bool {
 auto Context::ParamOrArgStart() -> void { params_or_args_stack_.Push(); }
 
 auto Context::ParamOrArgComma() -> void {
-  ParamOrArgSave(node_stack_.PopExpression());
+  ParamOrArgSave(node_stack_.PopExpr());
 }
 
 auto Context::ParamOrArgEndNoPop(Parse::NodeKind start_kind) -> void {
   if (parse_tree_->node_kind(node_stack_.PeekParseNode()) != start_kind) {
-    ParamOrArgSave(node_stack_.PopExpression());
+    ParamOrArgSave(node_stack_.PopExpr());
   }
 }
 
@@ -800,7 +800,7 @@ class TypeCompleter {
       case SemIR::Parameter::Kind:
       case SemIR::RealLiteral::Kind:
       case SemIR::Return::Kind:
-      case SemIR::ReturnExpression::Kind:
+      case SemIR::ReturnExpr::Kind:
       case SemIR::SelfParameter::Kind:
       case SemIR::SpliceBlock::Kind:
       case SemIR::StringLiteral::Kind:
@@ -1003,7 +1003,7 @@ static auto ProfileType(Context& semantics_context, SemIR::Inst inst,
     }
     default: {
       // Right now, this is only expected to occur in calls from
-      // ExpressionAsType. Diagnostics are issued there.
+      // ExprAsType. Diagnostics are issued there.
       return false;
     }
   }

toolchain/check/convert.cpp

@@ -119,8 +119,8 @@ static auto FinalizeTemporary(Context& context, SemIR::InstId init_id,
 // an initializing expression.
 static auto MaterializeIfInitializing(Context& context, SemIR::InstId expr_id)
     -> SemIR::InstId {
-  if (GetExpressionCategory(context.sem_ir(), expr_id) ==
-      SemIR::ExpressionCategory::Initializing) {
+  if (GetExprCategory(context.sem_ir(), expr_id) ==
+      SemIR::ExprCategory::Initializing) {
     return FinalizeTemporary(context, expr_id, /*discarded=*/false);
   }
   return expr_id;
@@ -261,13 +261,13 @@ static auto ConvertTupleToArray(Context& context, SemIR::TupleType tuple_type,
         ArrayInitFromLiteralArgCountMismatch, Error,
         "Cannot initialize array of {0} element(s) from {1} initializer(s).",
         uint64_t, size_t);
-    CARBON_DIAGNOSTIC(ArrayInitFromExpressionArgCountMismatch, Error,
+    CARBON_DIAGNOSTIC(ArrayInitFromExprArgCountMismatch, Error,
                       "Cannot initialize array of {0} element(s) from tuple "
                       "with {1} element(s).",
                       uint64_t, size_t);
     context.emitter().Emit(value.parse_node(),
                            literal_elems.empty()
-                               ? ArrayInitFromExpressionArgCountMismatch
+                               ? ArrayInitFromExprArgCountMismatch
                                : ArrayInitFromLiteralArgCountMismatch,
                            array_bound, tuple_elem_types.size());
     return SemIR::InstId::BuiltinError;
@@ -568,22 +568,22 @@ static auto ConvertStructToClass(Context& context, SemIR::StructType src_type,
 // Returns whether `category` is a valid expression category to produce as a
 // result of a conversion with kind `target_kind`, or at most needs a temporary
 // to be materialized.
-static bool IsValidExpressionCategoryForConversionTarget(
-    SemIR::ExpressionCategory category, ConversionTarget::Kind target_kind) {
+static bool IsValidExprCategoryForConversionTarget(
+    SemIR::ExprCategory category, ConversionTarget::Kind target_kind) {
   switch (target_kind) {
     case ConversionTarget::Value:
-      return category == SemIR::ExpressionCategory::Value;
+      return category == SemIR::ExprCategory::Value;
     case ConversionTarget::ValueOrReference:
     case ConversionTarget::Discarded:
-      return category == SemIR::ExpressionCategory::Value ||
-             category == SemIR::ExpressionCategory::DurableReference ||
-             category == SemIR::ExpressionCategory::EphemeralReference ||
-             category == SemIR::ExpressionCategory::Initializing;
+      return category == SemIR::ExprCategory::Value ||
+             category == SemIR::ExprCategory::DurableReference ||
+             category == SemIR::ExprCategory::EphemeralReference ||
+             category == SemIR::ExprCategory::Initializing;
     case ConversionTarget::ExplicitAs:
       return true;
     case ConversionTarget::Initializer:
     case ConversionTarget::FullInitializer:
-      return category == SemIR::ExpressionCategory::Initializing;
+      return category == SemIR::ExprCategory::Initializing;
   }
 }
 
@@ -627,16 +627,16 @@ static auto PerformBuiltinConversion(Context& context, Parse::Node parse_node,
   // nothing to do. Performing a conversion would decompose and rebuild tuples
   // and structs, so it's important that we bail out early in this case.
   if (value_type_id == target.type_id) {
-    auto value_cat = SemIR::GetExpressionCategory(sem_ir, value_id);
-    if (IsValidExpressionCategoryForConversionTarget(value_cat, target.kind)) {
+    auto value_cat = SemIR::GetExprCategory(sem_ir, value_id);
+    if (IsValidExprCategoryForConversionTarget(value_cat, target.kind)) {
       return value_id;
     }
 
     // If the source is an initializing expression, we may be able to pull a
     // value right out of it.
-    if (value_cat == SemIR::ExpressionCategory::Initializing &&
-        IsValidExpressionCategoryForConversionTarget(
-            SemIR::ExpressionCategory::Value, target.kind) &&
+    if (value_cat == SemIR::ExprCategory::Initializing &&
+        IsValidExprCategoryForConversionTarget(SemIR::ExprCategory::Value,
+                                               target.kind) &&
         SemIR::GetInitializingRepresentation(sem_ir, value_type_id).kind ==
             SemIR::InitializingRepresentation::ByCopy) {
       auto value_rep = SemIR::GetValueRepresentation(sem_ir, value_type_id);
@@ -707,8 +707,7 @@ static auto PerformBuiltinConversion(Context& context, Parse::Node parse_node,
            sem_ir.inst_blocks().Get(tuple_literal->elements_id)) {
         // TODO: This call recurses back into conversion. Switch to an
         // iterative approach.
-        type_ids.push_back(
-            ExpressionAsType(context, parse_node, tuple_inst_id));
+        type_ids.push_back(ExprAsType(context, parse_node, tuple_inst_id));
       }
       auto tuple_type_id =
           context.CanonicalizeTupleType(parse_node, std::move(type_ids));
@@ -771,15 +770,14 @@ auto Convert(Context& context, Parse::Node parse_node, SemIR::InstId expr_id,
     return SemIR::InstId::BuiltinError;
   }
 
-  if (SemIR::GetExpressionCategory(sem_ir, expr_id) ==
-      SemIR::ExpressionCategory::NotExpression) {
+  if (SemIR::GetExprCategory(sem_ir, expr_id) == SemIR::ExprCategory::NotExpr) {
     // TODO: We currently encounter this for use of namespaces and functions.
     // We should provide a better diagnostic for inappropriate use of
     // namespace names, and allow use of functions as values.
-    CARBON_DIAGNOSTIC(UseOfNonExpressionAsValue, Error,
+    CARBON_DIAGNOSTIC(UseOfNonExprAsValue, Error,
                       "Expression cannot be used as a value.");
     context.emitter().Emit(sem_ir.insts().Get(expr_id).parse_node(),
-                           UseOfNonExpressionAsValue);
+                           UseOfNonExprAsValue);
     return SemIR::InstId::BuiltinError;
   }
 
@@ -845,16 +843,16 @@ auto Convert(Context& context, Parse::Node parse_node, SemIR::InstId expr_id,
   }
 
   // Now perform any necessary value category conversions.
-  switch (SemIR::GetExpressionCategory(sem_ir, expr_id)) {
-    case SemIR::ExpressionCategory::NotExpression:
-    case SemIR::ExpressionCategory::Mixed:
+  switch (SemIR::GetExprCategory(sem_ir, expr_id)) {
+    case SemIR::ExprCategory::NotExpr:
+    case SemIR::ExprCategory::Mixed:
       CARBON_FATAL() << "Unexpected expression " << expr
                      << " after builtin conversions";
 
-    case SemIR::ExpressionCategory::Error:
+    case SemIR::ExprCategory::Error:
       return SemIR::InstId::BuiltinError;
 
-    case SemIR::ExpressionCategory::Initializing:
+    case SemIR::ExprCategory::Initializing:
       if (target.is_initializer()) {
         if (orig_expr_id == expr_id) {
           // Don't fill in the return slot if we created the expression through
@@ -875,8 +873,8 @@ auto Convert(Context& context, Parse::Node parse_node, SemIR::InstId expr_id,
       // We now have an ephemeral reference.
       [[fallthrough]];
 
-    case SemIR::ExpressionCategory::DurableReference:
-    case SemIR::ExpressionCategory::EphemeralReference:
+    case SemIR::ExprCategory::DurableReference:
+    case SemIR::ExprCategory::EphemeralReference:
       // If a reference expression is an acceptable result, we're done.
       if (target.kind == ConversionTarget::ValueOrReference ||
           target.kind == ConversionTarget::Discarded) {
@@ -890,7 +888,7 @@ auto Convert(Context& context, Parse::Node parse_node, SemIR::InstId expr_id,
       // We now have a value expression.
       [[fallthrough]];
 
-    case SemIR::ExpressionCategory::Value:
+    case SemIR::ExprCategory::Value:
       // When initializing from a value, perform a copy.
       if (target.is_initializer()) {
         expr_id = PerformCopy(context, expr_id);
@@ -923,15 +921,14 @@ auto Initialize(Context& context, Parse::Node parse_node,
                   .init_block = &target_block});
 }
 
-auto ConvertToValueExpression(Context& context, SemIR::InstId expr_id)
+auto ConvertToValueExpr(Context& context, SemIR::InstId expr_id)
     -> SemIR::InstId {
   auto expr = context.sem_ir().insts().Get(expr_id);
   return Convert(context, expr.parse_node(), expr_id,
                  {.kind = ConversionTarget::Value, .type_id = expr.type_id()});
 }
 
-auto ConvertToValueOrReferenceExpression(Context& context,
-                                         SemIR::InstId expr_id)
+auto ConvertToValueOrReferenceExpr(Context& context, SemIR::InstId expr_id)
     -> SemIR::InstId {
   auto expr = context.sem_ir().insts().Get(expr_id);
   return Convert(
@@ -992,13 +989,12 @@ static auto ConvertSelf(Context& context, Parse::Node call_parse_node,
   // For `addr self`, take the address of the object argument.
   auto self_or_addr_id = self_id;
   if (self_param.is_addr_self.index) {
-    self_or_addr_id =
-        ConvertToValueOrReferenceExpression(context, self_or_addr_id);
+    self_or_addr_id = ConvertToValueOrReferenceExpr(context, self_or_addr_id);
     auto self = context.insts().Get(self_or_addr_id);
-    switch (SemIR::GetExpressionCategory(context.sem_ir(), self_id)) {
-      case SemIR::ExpressionCategory::Error:
-      case SemIR::ExpressionCategory::DurableReference:
-      case SemIR::ExpressionCategory::EphemeralReference:
+    switch (SemIR::GetExprCategory(context.sem_ir(), self_id)) {
+      case SemIR::ExprCategory::Error:
+      case SemIR::ExprCategory::DurableReference:
+      case SemIR::ExprCategory::EphemeralReference:
         break;
       default:
         CARBON_DIAGNOSTIC(AddrSelfIsNonReference, Error,
@@ -1097,8 +1093,8 @@ auto ConvertCallArgs(Context& context, Parse::Node call_parse_node,
   return context.inst_blocks().Add(args);
 }
 
-auto ExpressionAsType(Context& context, Parse::Node parse_node,
-                      SemIR::InstId value_id) -> SemIR::TypeId {
+auto ExprAsType(Context& context, Parse::Node parse_node,
+                SemIR::InstId value_id) -> SemIR::TypeId {
   auto type_inst_id = ConvertToValueOfType(context, parse_node, value_id,
                                            SemIR::TypeId::TypeType);
   if (type_inst_id == SemIR::InstId::BuiltinError) {
@@ -1106,9 +1102,9 @@ auto ExpressionAsType(Context& context, Parse::Node parse_node,
   }
   auto type_id = context.CanonicalizeType(type_inst_id);
   if (type_id == SemIR::TypeId::Error) {
-    CARBON_DIAGNOSTIC(TypeExpressionEvaluationFailure, Error,
+    CARBON_DIAGNOSTIC(TypeExprEvaluationFailure, Error,
                       "Cannot evaluate type expression.");
-    context.emitter().Emit(parse_node, TypeExpressionEvaluationFailure);
+    context.emitter().Emit(parse_node, TypeExprEvaluationFailure);
   }
   return type_id;
 }

toolchain/check/convert.h

@@ -63,13 +63,12 @@ auto Initialize(Context& context, Parse::Node parse_node,
     -> SemIR::InstId;
 
 // Convert the given expression to a value expression of the same type.
-auto ConvertToValueExpression(Context& context, SemIR::InstId expr_id)
+auto ConvertToValueExpr(Context& context, SemIR::InstId expr_id)
     -> SemIR::InstId;
 
 // Convert the given expression to a value or reference expression of the same
 // type.
-auto ConvertToValueOrReferenceExpression(Context& context,
-                                         SemIR::InstId expr_id)
+auto ConvertToValueOrReferenceExpr(Context& context, SemIR::InstId expr_id)
     -> SemIR::InstId;
 
 // Converts `value_id` to a value expression of type `type_id`.
@@ -98,8 +97,8 @@ auto ConvertCallArgs(Context& context, Parse::Node call_parse_node,
                      SemIR::InstBlockId param_refs_id) -> SemIR::InstBlockId;
 
 // Converts an expression for use as a type.
-auto ExpressionAsType(Context& context, Parse::Node parse_node,
-                      SemIR::InstId value_id) -> SemIR::TypeId;
+auto ExprAsType(Context& context, Parse::Node parse_node,
+                SemIR::InstId value_id) -> SemIR::TypeId;
 
 }  // namespace Carbon::Check
 

toolchain/check/handle_array.cpp

@@ -10,30 +10,29 @@
 
 namespace Carbon::Check {
 
-auto HandleArrayExpressionStart(Context& /*context*/,
-                                Parse::Node /*parse_node*/) -> bool {
+auto HandleArrayExprStart(Context& /*context*/, Parse::Node /*parse_node*/)
+    -> bool {
   return true;
 }
 
-auto HandleArrayExpressionSemi(Context& context, Parse::Node parse_node)
-    -> bool {
+auto HandleArrayExprSemi(Context& context, Parse::Node parse_node) -> bool {
   context.node_stack().Push(parse_node);
   return true;
 }
 
-auto HandleArrayExpression(Context& context, Parse::Node parse_node) -> bool {
+auto HandleArrayExpr(Context& context, Parse::Node parse_node) -> bool {
   // TODO: Handle array type with undefined bound.
   if (context.parse_tree().node_kind(context.node_stack().PeekParseNode()) ==
-      Parse::NodeKind::ArrayExpressionSemi) {
+      Parse::NodeKind::ArrayExprSemi) {
     context.node_stack().PopAndIgnore();
     context.node_stack().PopAndIgnore();
-    return context.TODO(parse_node, "HandleArrayExpressionWithoutBounds");
+    return context.TODO(parse_node, "HandleArrayExprWithoutBounds");
   }
 
-  auto bound_inst_id = context.node_stack().PopExpression();
+  auto bound_inst_id = context.node_stack().PopExpr();
   context.node_stack()
-      .PopAndDiscardSoloParseNode<Parse::NodeKind::ArrayExpressionSemi>();
-  auto element_type_inst_id = context.node_stack().PopExpression();
+      .PopAndDiscardSoloParseNode<Parse::NodeKind::ArrayExprSemi>();
+  auto element_type_inst_id = context.node_stack().PopExpr();
   auto bound_inst = context.insts().Get(bound_inst_id);
   if (auto literal = bound_inst.TryAs<SemIR::IntegerLiteral>()) {
     const auto& bound_value = context.integers().Get(literal->integer_id);
@@ -43,12 +42,12 @@ auto HandleArrayExpression(Context& context, Parse::Node parse_node) -> bool {
           parse_node,
           SemIR::ArrayType{
               parse_node, SemIR::TypeId::TypeType, bound_inst_id,
-              ExpressionAsType(context, parse_node, element_type_inst_id)});
+              ExprAsType(context, parse_node, element_type_inst_id)});
       return true;
     }
   }
-  CARBON_DIAGNOSTIC(InvalidArrayExpression, Error, "Invalid array expression.");
-  context.emitter().Emit(parse_node, InvalidArrayExpression);
+  CARBON_DIAGNOSTIC(InvalidArrayExpr, Error, "Invalid array expression.");
+  context.emitter().Emit(parse_node, InvalidArrayExpr);
   context.node_stack().Push(parse_node, SemIR::InstId::BuiltinError);
   return true;
 }

toolchain/check/handle_call_expression.cpp

@@ -9,16 +9,15 @@
 
 namespace Carbon::Check {
 
-auto HandleCallExpression(Context& context, Parse::Node parse_node) -> bool {
+auto HandleCallExpr(Context& context, Parse::Node parse_node) -> bool {
   // Process the final explicit call argument now, but leave the arguments
   // block on the stack until the end of this function.
-  context.ParamOrArgEndNoPop(Parse::NodeKind::CallExpressionStart);
+  context.ParamOrArgEndNoPop(Parse::NodeKind::CallExprStart);
   auto discard_args_block = llvm::make_scope_exit(
       [&] { context.params_or_args_stack().PopAndDiscard(); });
 
   auto [call_expr_parse_node, callee_id] =
-      context.node_stack()
-          .PopWithParseNode<Parse::NodeKind::CallExpressionStart>();
+      context.node_stack().PopWithParseNode<Parse::NodeKind::CallExprStart>();
 
   auto diagnose_not_callable = [&, call_expr_parse_node = call_expr_parse_node,
                                 callee_id = callee_id] {
@@ -85,15 +84,13 @@ auto HandleCallExpression(Context& context, Parse::Node parse_node) -> bool {
   return true;
 }
 
-auto HandleCallExpressionComma(Context& context, Parse::Node /*parse_node*/)
-    -> bool {
+auto HandleCallExprComma(Context& context, Parse::Node /*parse_node*/) -> bool {
   context.ParamOrArgComma();
   return true;
 }
 
-auto HandleCallExpressionStart(Context& context, Parse::Node parse_node)
-    -> bool {
-  auto name_id = context.node_stack().PopExpression();
+auto HandleCallExprStart(Context& context, Parse::Node parse_node) -> bool {
+  auto name_id = context.node_stack().PopExpr();
   context.node_stack().Push(parse_node, name_id);
   context.ParamOrArgStart();
   return true;

toolchain/check/handle_function.cpp

@@ -238,8 +238,8 @@ auto HandleFunctionIntroducer(Context& context, Parse::Node parse_node)
 auto HandleReturnType(Context& context, Parse::Node parse_node) -> bool {
   // Propagate the type expression.
   auto [type_parse_node, type_inst_id] =
-      context.node_stack().PopExpressionWithParseNode();
-  auto type_id = ExpressionAsType(context, type_parse_node, type_inst_id);
+      context.node_stack().PopExprWithParseNode();
+  auto type_id = ExprAsType(context, type_parse_node, type_inst_id);
   // TODO: Use a dedicated instruction rather than VarStorage here.
   context.AddInstAndPush(
       parse_node,

toolchain/check/handle_if_expression.cpp

@@ -7,11 +7,11 @@
 
 namespace Carbon::Check {
 
-auto HandleIfExpressionIf(Context& context, Parse::Node parse_node) -> bool {
+auto HandleIfExprIf(Context& context, Parse::Node parse_node) -> bool {
   // Alias parse_node for if/then/else consistency.
   auto& if_node = parse_node;
 
-  auto cond_value_id = context.node_stack().PopExpression();
+  auto cond_value_id = context.node_stack().PopExpr();
 
   // Convert the condition to `bool`, and branch on it.
   cond_value_id = ConvertToBoolValue(context, if_node, cond_value_id);
@@ -28,13 +28,12 @@ auto HandleIfExpressionIf(Context& context, Parse::Node parse_node) -> bool {
   return true;
 }
 
-auto HandleIfExpressionThen(Context& context, Parse::Node parse_node) -> bool {
-  auto then_value_id = context.node_stack().PopExpression();
-  auto else_block_id =
-      context.node_stack().Peek<Parse::NodeKind::IfExpressionIf>();
+auto HandleIfExprThen(Context& context, Parse::Node parse_node) -> bool {
+  auto then_value_id = context.node_stack().PopExpr();
+  auto else_block_id = context.node_stack().Peek<Parse::NodeKind::IfExprIf>();
 
   // Convert the first operand to a value.
-  then_value_id = ConvertToValueExpression(context, then_value_id);
+  then_value_id = ConvertToValueExpr(context, then_value_id);
 
   // Start emitting the `else` block.
   context.inst_block_stack().Push(else_block_id);
@@ -44,15 +43,14 @@ auto HandleIfExpressionThen(Context& context, Parse::Node parse_node) -> bool {
   return true;
 }
 
-auto HandleIfExpressionElse(Context& context, Parse::Node parse_node) -> bool {
+auto HandleIfExprElse(Context& context, Parse::Node parse_node) -> bool {
   // Alias parse_node for if/then/else consistency.
   auto& else_node = parse_node;
 
-  auto else_value_id = context.node_stack().PopExpression();
-  auto then_value_id =
-      context.node_stack().Pop<Parse::NodeKind::IfExpressionThen>();
+  auto else_value_id = context.node_stack().PopExpr();
+  auto then_value_id = context.node_stack().Pop<Parse::NodeKind::IfExprThen>();
   auto [if_node, _] =
-      context.node_stack().PopWithParseNode<Parse::NodeKind::IfExpressionIf>();
+      context.node_stack().PopWithParseNode<Parse::NodeKind::IfExprIf>();
 
   // Convert the `else` value to the `then` value's type, and finish the `else`
   // block.

toolchain/check/handle_if_statement.cpp

@@ -15,7 +15,7 @@ auto HandleIfConditionStart(Context& /*context*/, Parse::Node /*parse_node*/)
 
 auto HandleIfCondition(Context& context, Parse::Node parse_node) -> bool {
   // Convert the condition to `bool`.
-  auto cond_value_id = context.node_stack().PopExpression();
+  auto cond_value_id = context.node_stack().PopExpr();
   cond_value_id = ConvertToBoolValue(context, parse_node, cond_value_id);
 
   // Create the then block and the else block, and branch to the right one. If

toolchain/check/handle_index.cpp

@@ -10,9 +10,9 @@
 
 namespace Carbon::Check {
 
-auto HandleIndexExpressionStart(Context& /*context*/,
-                                Parse::Node /*parse_node*/) -> bool {
-  // Leave the expression on the stack for IndexExpression.
+auto HandleIndexExprStart(Context& /*context*/, Parse::Node /*parse_node*/)
+    -> bool {
+  // Leave the expression on the stack for IndexExpr.
   return true;
 }
 
@@ -37,12 +37,11 @@ static auto ValidateIntegerLiteralBound(Context& context,
   return &index_val;
 }
 
-auto HandleIndexExpression(Context& context, Parse::Node parse_node) -> bool {
-  auto index_inst_id = context.node_stack().PopExpression();
+auto HandleIndexExpr(Context& context, Parse::Node parse_node) -> bool {
+  auto index_inst_id = context.node_stack().PopExpr();
   auto index_inst = context.insts().Get(index_inst_id);
-  auto operand_inst_id = context.node_stack().PopExpression();
-  operand_inst_id =
-      ConvertToValueOrReferenceExpression(context, operand_inst_id);
+  auto operand_inst_id = context.node_stack().PopExpr();
+  operand_inst_id = ConvertToValueOrReferenceExpr(context, operand_inst_id);
   auto operand_inst = context.insts().Get(operand_inst_id);
   auto operand_type_id = operand_inst.type_id();
   auto operand_type_inst = context.insts().Get(
@@ -64,8 +63,8 @@ auto HandleIndexExpression(Context& context, Parse::Node parse_node) -> bool {
           context, index_inst.parse_node(), index_inst_id,
           context.GetBuiltinType(SemIR::BuiltinKind::IntegerType));
       auto array_cat =
-          SemIR::GetExpressionCategory(context.sem_ir(), operand_inst_id);
-      if (array_cat == SemIR::ExpressionCategory::Value) {
+          SemIR::GetExprCategory(context.sem_ir(), operand_inst_id);
+      if (array_cat == SemIR::ExprCategory::Value) {
         // If the operand is an array value, convert it to an ephemeral
         // reference to an array so we can perform a primitive indexing into it.
         operand_inst_id = context.AddInst(SemIR::ValueAsReference{
@@ -74,12 +73,12 @@ auto HandleIndexExpression(Context& context, Parse::Node parse_node) -> bool {
       auto elem_id = context.AddInst(
           SemIR::ArrayIndex{parse_node, array_type.element_type_id,
                             operand_inst_id, cast_index_id});
-      if (array_cat != SemIR::ExpressionCategory::DurableReference) {
+      if (array_cat != SemIR::ExprCategory::DurableReference) {
         // Indexing a durable reference gives a durable reference expression.
         // Indexing anything else gives a value expression.
         // TODO: This should be replaced by a choice between using `IndexWith`
         // and `IndirectIndexWith`.
-        elem_id = ConvertToValueExpression(context, elem_id);
+        elem_id = ConvertToValueExpr(context, elem_id);
       }
       context.node_stack().Push(parse_node, elem_id);
       return true;

toolchain/check/handle_let.cpp

@@ -9,7 +9,7 @@
 namespace Carbon::Check {
 
 auto HandleLetDeclaration(Context& context, Parse::Node parse_node) -> bool {
-  auto value_id = context.node_stack().PopExpression();
+  auto value_id = context.node_stack().PopExpr();
   SemIR::InstId pattern_id =
       context.node_stack().Pop<Parse::NodeKind::PatternBinding>();
   context.node_stack()

toolchain/check/handle_loop_statement.cpp

@@ -82,7 +82,7 @@ auto HandleWhileConditionStart(Context& context, Parse::Node parse_node)
 }
 
 auto HandleWhileCondition(Context& context, Parse::Node parse_node) -> bool {
-  auto cond_value_id = context.node_stack().PopExpression();
+  auto cond_value_id = context.node_stack().PopExpr();
   auto loop_header_id =
       context.node_stack().Peek<Parse::NodeKind::WhileConditionStart>();
   cond_value_id = ConvertToBoolValue(context, parse_node, cond_value_id);

toolchain/check/handle_name.cpp

@@ -21,13 +21,13 @@ static auto GetAsNameScope(Context& context, SemIR::InstId base_id)
   if (auto base_as_class = base.TryAs<SemIR::ClassType>()) {
     auto& class_info = context.classes().Get(base_as_class->class_id);
     if (!class_info.is_defined()) {
-      CARBON_DIAGNOSTIC(QualifiedExpressionInIncompleteClassScope, Error,
+      CARBON_DIAGNOSTIC(QualifiedExprInIncompleteClassScope, Error,
                         "Member access into incomplete class `{0}`.",
                         std::string);
       auto builder = context.emitter().Build(
           context.insts().Get(base_id).parse_node(),
-          QualifiedExpressionInIncompleteClassScope,
-          context.sem_ir().StringifyTypeExpression(base_id, true));
+          QualifiedExprInIncompleteClassScope,
+          context.sem_ir().StringifyTypeExpr(base_id, true));
       context.NoteIncompleteClass(base_as_class->class_id, builder);
       builder.Emit();
     }
@@ -38,8 +38,8 @@ static auto GetAsNameScope(Context& context, SemIR::InstId base_id)
 
 // Given an instruction produced by a name lookup, get the value to use for that
 // result in an expression.
-static auto GetExpressionValueForLookupResult(Context& context,
-                                              SemIR::InstId lookup_result_id)
+static auto GetExprValueForLookupResult(Context& context,
+                                        SemIR::InstId lookup_result_id)
     -> SemIR::InstId {
   // If lookup finds a class declaration, the value is its `Self` type.
   auto lookup_result = context.insts().Get(lookup_result_id);
@@ -54,10 +54,9 @@ static auto GetExpressionValueForLookupResult(Context& context,
   return lookup_result_id;
 }
 
-auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
-    -> bool {
+auto HandleMemberAccessExpr(Context& context, Parse::Node parse_node) -> bool {
   SemIR::NameId name_id = context.node_stack().Pop<Parse::NodeKind::Name>();
-  auto base_id = context.node_stack().PopExpression();
+  auto base_id = context.node_stack().PopExpr();
 
   // If the base is a name scope, such as a class or namespace, perform lookup
   // into that scope.
@@ -66,7 +65,7 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
         name_scope_id->is_valid()
             ? context.LookupQualifiedName(parse_node, name_id, *name_scope_id)
             : SemIR::InstId::BuiltinError;
-    inst_id = GetExpressionValueForLookupResult(context, inst_id);
+    inst_id = GetExprValueForLookupResult(context, inst_id);
     auto inst = context.insts().Get(inst_id);
     // TODO: Track that this instruction was named within `base_id`.
     context.AddInstAndPush(
@@ -91,7 +90,7 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
   }
 
   // Materialize a temporary for the base expression if necessary.
-  base_id = ConvertToValueOrReferenceExpression(context, base_id);
+  base_id = ConvertToValueOrReferenceExpr(context, base_id);
   base_type_id = context.insts().Get(base_id).type_id();
 
   auto base_type = context.insts().Get(
@@ -105,7 +104,7 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
                                 .scope_id;
       auto member_id =
           context.LookupQualifiedName(parse_node, name_id, class_scope_id);
-      member_id = GetExpressionValueForLookupResult(context, member_id);
+      member_id = GetExprValueForLookupResult(context, member_id);
 
       // Perform instance binding if we found an instance member.
       auto member_type_id = context.insts().Get(member_id).type_id();
@@ -128,16 +127,16 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
         auto access_id = context.AddInst(SemIR::ClassFieldAccess{
             parse_node, unbound_field_type->field_type_id, base_id,
             field->index});
-        if (SemIR::GetExpressionCategory(context.sem_ir(), base_id) ==
-                SemIR::ExpressionCategory::Value &&
-            SemIR::GetExpressionCategory(context.sem_ir(), access_id) !=
-                SemIR::ExpressionCategory::Value) {
+        if (SemIR::GetExprCategory(context.sem_ir(), base_id) ==
+                SemIR::ExprCategory::Value &&
+            SemIR::GetExprCategory(context.sem_ir(), access_id) !=
+                SemIR::ExprCategory::Value) {
           // Class field access on a value expression produces an ephemeral
           // reference if the class's value representation is a pointer to the
           // object representation. Add a value binding in that case so that the
           // expression category of the result matches the expression category
           // of the base.
-          access_id = ConvertToValueExpression(context, access_id);
+          access_id = ConvertToValueExpr(context, access_id);
         }
         context.node_stack().Push(parse_node, access_id);
         return true;
@@ -190,10 +189,10 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
           return true;
         }
       }
-      CARBON_DIAGNOSTIC(QualifiedExpressionNameNotFound, Error,
+      CARBON_DIAGNOSTIC(QualifiedExprNameNotFound, Error,
                         "Type `{0}` does not have a member `{1}`.", std::string,
                         llvm::StringRef);
-      context.emitter().Emit(parse_node, QualifiedExpressionNameNotFound,
+      context.emitter().Emit(parse_node, QualifiedExprNameNotFound,
                              context.sem_ir().StringifyType(base_type_id),
                              context.names().GetFormatted(name_id));
       break;
@@ -203,10 +202,10 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
     // type if it creates a reference expression performing field access.
     default: {
       if (base_type_id != SemIR::TypeId::Error) {
-        CARBON_DIAGNOSTIC(QualifiedExpressionUnsupported, Error,
+        CARBON_DIAGNOSTIC(QualifiedExprUnsupported, Error,
                           "Type `{0}` does not support qualified expressions.",
                           std::string);
-        context.emitter().Emit(parse_node, QualifiedExpressionUnsupported,
+        context.emitter().Emit(parse_node, QualifiedExprUnsupported,
                                context.sem_ir().StringifyType(base_type_id));
       }
       break;
@@ -218,9 +217,9 @@ auto HandleMemberAccessExpression(Context& context, Parse::Node parse_node)
   return true;
 }
 
-auto HandlePointerMemberAccessExpression(Context& context,
-                                         Parse::Node parse_node) -> bool {
-  return context.TODO(parse_node, "HandlePointerMemberAccessExpression");
+auto HandlePointerMemberAccessExpr(Context& context, Parse::Node parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePointerMemberAccessExpr");
 }
 
 auto HandleName(Context& context, Parse::Node parse_node) -> bool {
@@ -231,11 +230,11 @@ auto HandleName(Context& context, Parse::Node parse_node) -> bool {
   return true;
 }
 
-auto HandleNameExpression(Context& context, Parse::Node parse_node) -> bool {
+auto HandleNameExpr(Context& context, Parse::Node parse_node) -> bool {
   auto name_id = SemIR::NameId::ForIdentifier(context.tokens().GetIdentifier(
       context.parse_tree().node_token(parse_node)));
   auto value_id = context.LookupUnqualifiedName(parse_node, name_id);
-  value_id = GetExpressionValueForLookupResult(context, value_id);
+  value_id = GetExprValueForLookupResult(context, value_id);
   auto value = context.insts().Get(value_id);
   context.AddInstAndPush(
       parse_node,
@@ -275,8 +274,7 @@ auto HandleQualifiedDeclaration(Context& context, Parse::Node parse_node)
   return true;
 }
 
-auto HandleSelfTypeNameExpression(Context& context, Parse::Node parse_node)
-    -> bool {
+auto HandleSelfTypeNameExpr(Context& context, Parse::Node parse_node) -> bool {
   auto name_id = SemIR::NameId::SelfType;
   auto value_id = context.LookupUnqualifiedName(parse_node, name_id);
   auto value = context.insts().Get(value_id);
@@ -291,8 +289,7 @@ auto HandleSelfValueName(Context& context, Parse::Node parse_node) -> bool {
   return true;
 }
 
-auto HandleSelfValueNameExpression(Context& context, Parse::Node parse_node)
-    -> bool {
+auto HandleSelfValueNameExpr(Context& context, Parse::Node parse_node) -> bool {
   auto name_id = SemIR::NameId::SelfValue;
   auto value_id = context.LookupUnqualifiedName(parse_node, name_id);
   auto value = context.insts().Get(value_id);

toolchain/check/handle_operator.cpp

@@ -8,8 +8,8 @@
 namespace Carbon::Check {
 
 auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool {
-  auto [rhs_node, rhs_id] = context.node_stack().PopExpressionWithParseNode();
-  auto [lhs_node, lhs_id] = context.node_stack().PopExpressionWithParseNode();
+  auto [rhs_node, rhs_id] = context.node_stack().PopExprWithParseNode();
+  auto [lhs_node, lhs_id] = context.node_stack().PopExprWithParseNode();
 
   // Figure out the operator for the token.
   auto token = context.parse_tree().node_token(parse_node);
@@ -19,7 +19,7 @@ auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool {
       // very trivial check of validity on the operation.
       lhs_id = ConvertToValueOfType(context, parse_node, lhs_id,
                                     context.insts().Get(rhs_id).type_id());
-      rhs_id = ConvertToValueExpression(context, rhs_id);
+      rhs_id = ConvertToValueExpr(context, rhs_id);
 
       context.AddInstAndPush(
           parse_node, SemIR::BinaryOperatorAdd{
@@ -50,7 +50,7 @@ auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool {
       return true;
     }
     case Lex::TokenKind::As: {
-      auto rhs_type_id = ExpressionAsType(context, rhs_node, rhs_id);
+      auto rhs_type_id = ExprAsType(context, rhs_node, rhs_id);
       context.node_stack().Push(
           parse_node,
           ConvertForExplicitAs(context, parse_node, lhs_id, rhs_type_id));
@@ -58,9 +58,9 @@ auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool {
     }
     case Lex::TokenKind::Equal: {
       // TODO: handle complex assignment expression such as `a += 1`.
-      if (auto lhs_cat = SemIR::GetExpressionCategory(context.sem_ir(), lhs_id);
-          lhs_cat != SemIR::ExpressionCategory::DurableReference &&
-          lhs_cat != SemIR::ExpressionCategory::Error) {
+      if (auto lhs_cat = SemIR::GetExprCategory(context.sem_ir(), lhs_id);
+          lhs_cat != SemIR::ExprCategory::DurableReference &&
+          lhs_cat != SemIR::ExprCategory::Error) {
         CARBON_DIAGNOSTIC(AssignmentToNonAssignable, Error,
                           "Expression is not assignable.");
         context.emitter().Emit(lhs_node, AssignmentToNonAssignable);
@@ -82,13 +82,13 @@ auto HandleInfixOperator(Context& context, Parse::Node parse_node) -> bool {
 }
 
 auto HandlePostfixOperator(Context& context, Parse::Node parse_node) -> bool {
-  auto value_id = context.node_stack().PopExpression();
+  auto value_id = context.node_stack().PopExpr();
 
   // Figure out the operator for the token.
   auto token = context.parse_tree().node_token(parse_node);
   switch (auto token_kind = context.tokens().GetKind(token)) {
     case Lex::TokenKind::Star: {
-      auto inner_type_id = ExpressionAsType(context, parse_node, value_id);
+      auto inner_type_id = ExprAsType(context, parse_node, value_id);
       context.AddInstAndPush(
           parse_node, SemIR::PointerType{parse_node, SemIR::TypeId::TypeType,
                                          inner_type_id});
@@ -101,18 +101,18 @@ auto HandlePostfixOperator(Context& context, Parse::Node parse_node) -> bool {
 }
 
 auto HandlePrefixOperator(Context& context, Parse::Node parse_node) -> bool {
-  auto value_id = context.node_stack().PopExpression();
+  auto value_id = context.node_stack().PopExpr();
 
   // Figure out the operator for the token.
   auto token = context.parse_tree().node_token(parse_node);
   switch (auto token_kind = context.tokens().GetKind(token)) {
     case Lex::TokenKind::Amp: {
       // Only durable reference expressions can have their address taken.
-      switch (SemIR::GetExpressionCategory(context.sem_ir(), value_id)) {
-        case SemIR::ExpressionCategory::DurableReference:
-        case SemIR::ExpressionCategory::Error:
+      switch (SemIR::GetExprCategory(context.sem_ir(), value_id)) {
+        case SemIR::ExprCategory::DurableReference:
+        case SemIR::ExprCategory::Error:
           break;
-        case SemIR::ExpressionCategory::EphemeralReference:
+        case SemIR::ExprCategory::EphemeralReference:
           CARBON_DIAGNOSTIC(AddressOfEphemeralReference, Error,
                             "Cannot take the address of a temporary object.");
           context.emitter().Emit(parse_node, AddressOfEphemeralReference);
@@ -144,7 +144,7 @@ auto HandlePrefixOperator(Context& context, Parse::Node parse_node) -> bool {
                           "additional effect.");
         context.emitter().Emit(parse_node, RepeatedConst);
       }
-      auto inner_type_id = ExpressionAsType(context, parse_node, value_id);
+      auto inner_type_id = ExprAsType(context, parse_node, value_id);
       context.AddInstAndPush(
           parse_node,
           SemIR::ConstType{parse_node, SemIR::TypeId::TypeType, inner_type_id});
@@ -160,7 +160,7 @@ auto HandlePrefixOperator(Context& context, Parse::Node parse_node) -> bool {
       return true;
 
     case Lex::TokenKind::Star: {
-      value_id = ConvertToValueExpression(context, value_id);
+      value_id = ConvertToValueExpr(context, value_id);
       auto type_id =
           context.GetUnqualifiedType(context.insts().Get(value_id).type_id());
       auto type_inst = context.insts().Get(
@@ -198,7 +198,7 @@ auto HandlePrefixOperator(Context& context, Parse::Node parse_node) -> bool {
 auto HandleShortCircuitOperand(Context& context, Parse::Node parse_node)
     -> bool {
   // Convert the condition to `bool`.
-  auto cond_value_id = context.node_stack().PopExpression();
+  auto cond_value_id = context.node_stack().PopExpr();
   cond_value_id = ConvertToBoolValue(context, parse_node, cond_value_id);
   auto bool_type_id = context.insts().Get(cond_value_id).type_id();
 

toolchain/check/handle_paren.cpp

@@ -8,20 +8,20 @@
 
 namespace Carbon::Check {
 
-auto HandleParenExpression(Context& context, Parse::Node parse_node) -> bool {
-  auto value_id = context.node_stack().PopExpression();
+auto HandleParenExpr(Context& context, Parse::Node parse_node) -> bool {
+  auto value_id = context.node_stack().PopExpr();
   // ParamOrArgStart was called for tuple handling; clean up the ParamOrArg
   // support for non-tuple cases.
-  context.ParamOrArgEnd(Parse::NodeKind::ParenExpressionOrTupleLiteralStart);
+  context.ParamOrArgEnd(Parse::NodeKind::ParenExprOrTupleLiteralStart);
   context.node_stack()
       .PopAndDiscardSoloParseNode<
-          Parse::NodeKind::ParenExpressionOrTupleLiteralStart>();
+          Parse::NodeKind::ParenExprOrTupleLiteralStart>();
   context.node_stack().Push(parse_node, value_id);
   return true;
 }
 
-auto HandleParenExpressionOrTupleLiteralStart(Context& context,
-                                              Parse::Node parse_node) -> bool {
+auto HandleParenExprOrTupleLiteralStart(Context& context,
+                                        Parse::Node parse_node) -> bool {
   context.node_stack().Push(parse_node);
   context.ParamOrArgStart();
   return true;
@@ -34,12 +34,12 @@ auto HandleTupleLiteralComma(Context& context, Parse::Node /*parse_node*/)
 }
 
 auto HandleTupleLiteral(Context& context, Parse::Node parse_node) -> bool {
-  auto refs_id = context.ParamOrArgEnd(
-      Parse::NodeKind::ParenExpressionOrTupleLiteralStart);
+  auto refs_id =
+      context.ParamOrArgEnd(Parse::NodeKind::ParenExprOrTupleLiteralStart);
 
   context.node_stack()
       .PopAndDiscardSoloParseNode<
-          Parse::NodeKind::ParenExpressionOrTupleLiteralStart>();
+          Parse::NodeKind::ParenExprOrTupleLiteralStart>();
   const auto& inst_block = context.inst_blocks().Get(refs_id);
   llvm::SmallVector<SemIR::TypeId> type_ids;
   type_ids.reserve(inst_block.size());

toolchain/check/handle_pattern_binding.cpp

@@ -30,9 +30,9 @@ auto HandleGenericPatternBinding(Context& context, Parse::Node parse_node)
 
 auto HandlePatternBinding(Context& context, Parse::Node parse_node) -> bool {
   auto [type_node, parsed_type_id] =
-      context.node_stack().PopExpressionWithParseNode();
+      context.node_stack().PopExprWithParseNode();
   auto type_node_copy = type_node;
-  auto cast_type_id = ExpressionAsType(context, type_node, parsed_type_id);
+  auto cast_type_id = ExprAsType(context, type_node, parsed_type_id);
 
   // A `self` binding doesn't have a name.
   if (auto self_node =

toolchain/check/handle_statement.cpp

@@ -10,7 +10,7 @@ namespace Carbon::Check {
 
 // TODO: Find a better home for this. We'll likely need it for more than just
 // expression statements.
-static auto HandleDiscardedExpression(Context& context, SemIR::InstId expr_id)
+static auto HandleDiscardedExpr(Context& context, SemIR::InstId expr_id)
     -> void {
   // If we discard an initializing expression, convert it to a value or
   // reference so that it has something to initialize.
@@ -21,9 +21,8 @@ static auto HandleDiscardedExpression(Context& context, SemIR::InstId expr_id)
   // TODO: This will eventually need to do some "do not discard" analysis.
 }
 
-auto HandleExpressionStatement(Context& context, Parse::Node /*parse_node*/)
-    -> bool {
-  HandleDiscardedExpression(context, context.node_stack().PopExpression());
+auto HandleExprStatement(Context& context, Parse::Node /*parse_node*/) -> bool {
+  HandleDiscardedExpr(context, context.node_stack().PopExpr());
   return true;
 }
 
@@ -40,28 +39,28 @@ auto HandleReturnStatement(Context& context, Parse::Node parse_node) -> bool {
 
     if (callable.return_type_id.is_valid()) {
       // TODO: Add a note pointing at the return type's parse node.
-      CARBON_DIAGNOSTIC(ReturnStatementMissingExpression, Error,
-                        "Must return a {0}.", std::string);
+      CARBON_DIAGNOSTIC(ReturnStatementMissingExpr, Error, "Must return a {0}.",
+                        std::string);
       context.emitter()
-          .Build(parse_node, ReturnStatementMissingExpression,
+          .Build(parse_node, ReturnStatementMissingExpr,
                  context.sem_ir().StringifyType(callable.return_type_id))
           .Emit();
     }
 
     context.AddInst(SemIR::Return{parse_node});
   } else {
-    auto arg = context.node_stack().PopExpression();
+    auto arg = context.node_stack().PopExpr();
     context.node_stack()
         .PopAndDiscardSoloParseNode<Parse::NodeKind::ReturnStatementStart>();
 
     if (!callable.return_type_id.is_valid()) {
       CARBON_DIAGNOSTIC(
-          ReturnStatementDisallowExpression, Error,
+          ReturnStatementDisallowExpr, Error,
           "No return expression should be provided in this context.");
       CARBON_DIAGNOSTIC(ReturnStatementImplicitNote, Note,
                         "There was no return type provided.");
       context.emitter()
-          .Build(parse_node, ReturnStatementDisallowExpression)
+          .Build(parse_node, ReturnStatementDisallowExpr)
           .Note(fn_inst.parse_node, ReturnStatementImplicitNote)
           .Emit();
     } else if (callable.return_slot_id.is_valid()) {
@@ -71,7 +70,7 @@ auto HandleReturnStatement(Context& context, Parse::Node parse_node) -> bool {
                                  callable.return_type_id);
     }
 
-    context.AddInst(SemIR::ReturnExpression{parse_node, arg});
+    context.AddInst(SemIR::ReturnExpr{parse_node, arg});
   }
 
   // Switch to a new, unreachable, empty instruction block. This typically won't

toolchain/check/handle_struct.cpp

@@ -22,8 +22,8 @@ auto HandleStructFieldDesignator(Context& context, Parse::Node /*parse_node*/)
 }
 
 auto HandleStructFieldType(Context& context, Parse::Node parse_node) -> bool {
-  auto [type_node, type_id] = context.node_stack().PopExpressionWithParseNode();
-  SemIR::TypeId cast_type_id = ExpressionAsType(context, type_node, type_id);
+  auto [type_node, type_id] = context.node_stack().PopExprWithParseNode();
+  SemIR::TypeId cast_type_id = ExprAsType(context, type_node, type_id);
 
   auto [name_node, name_id] =
       context.node_stack().PopWithParseNode<Parse::NodeKind::Name>();
@@ -40,7 +40,7 @@ auto HandleStructFieldUnknown(Context& context, Parse::Node parse_node)
 
 auto HandleStructFieldValue(Context& context, Parse::Node parse_node) -> bool {
   auto [value_parse_node, value_inst_id] =
-      context.node_stack().PopExpressionWithParseNode();
+      context.node_stack().PopExprWithParseNode();
   SemIR::NameId name_id = context.node_stack().Pop<Parse::NodeKind::Name>();
 
   // Store the name for the type.

toolchain/check/handle_variable.cpp

@@ -16,7 +16,7 @@ auto HandleVariableDeclaration(Context& context, Parse::Node parse_node)
       context.parse_tree().node_kind(context.node_stack().PeekParseNode()) !=
       Parse::NodeKind::PatternBinding;
   if (has_init) {
-    init_id = context.node_stack().PopExpression();
+    init_id = context.node_stack().PopExpr();
     context.node_stack()
         .PopAndDiscardSoloParseNode<Parse::NodeKind::VariableInitializer>();
   }

toolchain/check/node_stack.h

@@ -102,7 +102,7 @@ class NodeStack {
 
   // Pops an expression from the top of the stack and returns the parse_node and
   // the ID.
-  auto PopExpressionWithParseNode() -> std::pair<Parse::Node, SemIR::InstId> {
+  auto PopExprWithParseNode() -> std::pair<Parse::Node, SemIR::InstId> {
     return PopWithParseNode<SemIR::InstId>();
   }
 
@@ -148,9 +148,7 @@ class NodeStack {
 
   // Pops an expression from the top of the stack and returns the ID.
   // Expressions map multiple Parse::NodeKinds to SemIR::InstId always.
-  auto PopExpression() -> SemIR::InstId {
-    return PopExpressionWithParseNode().second;
-  }
+  auto PopExpr() -> SemIR::InstId { return PopExprWithParseNode().second; }
 
   // Pops the top of the stack and returns the ID.
   template <Parse::NodeKind::RawEnumType RequiredParseKind>
@@ -282,23 +280,23 @@ 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::ArrayExpression:
-      case Parse::NodeKind::CallExpression:
-      case Parse::NodeKind::CallExpressionStart:
-      case Parse::NodeKind::IfExpressionThen:
-      case Parse::NodeKind::IfExpressionElse:
-      case Parse::NodeKind::IndexExpression:
+      case Parse::NodeKind::ArrayExpr:
+      case Parse::NodeKind::CallExpr:
+      case Parse::NodeKind::CallExprStart:
+      case Parse::NodeKind::IfExprThen:
+      case Parse::NodeKind::IfExprElse:
+      case Parse::NodeKind::IndexExpr:
       case Parse::NodeKind::InfixOperator:
       case Parse::NodeKind::Literal:
-      case Parse::NodeKind::MemberAccessExpression:
-      case Parse::NodeKind::NameExpression:
-      case Parse::NodeKind::ParenExpression:
+      case Parse::NodeKind::MemberAccessExpr:
+      case Parse::NodeKind::NameExpr:
+      case Parse::NodeKind::ParenExpr:
       case Parse::NodeKind::PatternBinding:
       case Parse::NodeKind::PostfixOperator:
       case Parse::NodeKind::PrefixOperator:
       case Parse::NodeKind::ReturnType:
-      case Parse::NodeKind::SelfTypeNameExpression:
-      case Parse::NodeKind::SelfValueNameExpression:
+      case Parse::NodeKind::SelfTypeNameExpr:
+      case Parse::NodeKind::SelfValueNameExpr:
       case Parse::NodeKind::ShortCircuitOperand:
       case Parse::NodeKind::StructFieldValue:
       case Parse::NodeKind::StructLiteral:
@@ -307,7 +305,7 @@ class NodeStack {
       case Parse::NodeKind::TupleLiteral:
         return IdKind::InstId;
       case Parse::NodeKind::IfCondition:
-      case Parse::NodeKind::IfExpressionIf:
+      case Parse::NodeKind::IfExprIf:
       case Parse::NodeKind::ImplicitParameterList:
       case Parse::NodeKind::ParameterList:
       case Parse::NodeKind::WhileCondition:
@@ -319,7 +317,7 @@ class NodeStack {
         return IdKind::ClassId;
       case Parse::NodeKind::Name:
         return IdKind::NameId;
-      case Parse::NodeKind::ArrayExpressionSemi:
+      case Parse::NodeKind::ArrayExprSemi:
       case Parse::NodeKind::ClassIntroducer:
       case Parse::NodeKind::CodeBlockStart:
       case Parse::NodeKind::FunctionIntroducer:
@@ -327,7 +325,7 @@ class NodeStack {
       case Parse::NodeKind::ImplicitParameterListStart:
       case Parse::NodeKind::LetIntroducer:
       case Parse::NodeKind::ParameterListStart:
-      case Parse::NodeKind::ParenExpressionOrTupleLiteralStart:
+      case Parse::NodeKind::ParenExprOrTupleLiteralStart:
       case Parse::NodeKind::QualifiedDeclaration:
       case Parse::NodeKind::ReturnStatementStart:
       case Parse::NodeKind::SelfValueName:

toolchain/check/testdata/array/fail_undefined_bound.carbon

@@ -4,7 +4,7 @@
 //
 // AUTOUPDATE
 
-// CHECK:STDERR: fail_undefined_bound.carbon:[[@LINE+3]]:14: ERROR: Semantics TODO: `HandleArrayExpressionWithoutBounds`.
+// CHECK:STDERR: fail_undefined_bound.carbon:[[@LINE+3]]:14: ERROR: Semantics TODO: `HandleArrayExprWithoutBounds`.
 // CHECK:STDERR: var a: [i32; ];
 // CHECK:STDERR:              ^
 var a: [i32; ];

toolchain/check/testdata/basics/raw_and_textual_ir.carbon

@@ -53,7 +53,7 @@ fn Foo(n: i32) -> (i32, f64) {
 // CHECK:STDOUT:     inst+16:         {kind: InitializeFrom, arg0: inst+11, arg1: inst+15, type: type2}
 // CHECK:STDOUT:     inst+17:         {kind: TupleInit, arg0: block6, arg1: inst+5, type: type3}
 // CHECK:STDOUT:     inst+18:         {kind: Converted, arg0: inst+12, arg1: inst+17, type: type3}
-// CHECK:STDOUT:     inst+19:         {kind: ReturnExpression, arg0: inst+18}
+// CHECK:STDOUT:     inst+19:         {kind: ReturnExpr, arg0: inst+18}
 // CHECK:STDOUT:   inst_blocks:
 // CHECK:STDOUT:     block0:          {}
 // CHECK:STDOUT:     block1:

toolchain/check/testdata/basics/raw_ir.carbon

@@ -53,7 +53,7 @@ fn Foo(n: i32) -> (i32, f64) {
 // CHECK:STDOUT:     inst+16:         {kind: InitializeFrom, arg0: inst+11, arg1: inst+15, type: type2}
 // CHECK:STDOUT:     inst+17:         {kind: TupleInit, arg0: block6, arg1: inst+5, type: type3}
 // CHECK:STDOUT:     inst+18:         {kind: Converted, arg0: inst+12, arg1: inst+17, type: type3}
-// CHECK:STDOUT:     inst+19:         {kind: ReturnExpression, arg0: inst+18}
+// CHECK:STDOUT:     inst+19:         {kind: ReturnExpr, arg0: inst+18}
 // CHECK:STDOUT:   inst_blocks:
 // CHECK:STDOUT:     block0:          {}
 // CHECK:STDOUT:     block1:

toolchain/check/testdata/class/method.carbon

@@ -36,11 +36,11 @@ fn CallGThroughPointer(p: Class*) -> i32 {
 
 fn Make() -> Class;
 
-fn CallFOnInitializingExpression() -> i32 {
+fn CallFOnInitializingExpr() -> i32 {
   return Make().F();
 }
 
-fn CallGOnInitializingExpression() -> i32 {
+fn CallGOnInitializingExpr() -> i32 {
   return Make().G();
 }
 
@@ -58,8 +58,8 @@ fn CallGOnInitializingExpression() -> i32 {
 // CHECK:STDOUT:   %CallFThroughPointer: <function> = fn_decl @CallFThroughPointer
 // CHECK:STDOUT:   %CallGThroughPointer: <function> = fn_decl @CallGThroughPointer
 // CHECK:STDOUT:   %Make: <function> = fn_decl @Make
-// CHECK:STDOUT:   %CallFOnInitializingExpression: <function> = fn_decl @CallFOnInitializingExpression
-// CHECK:STDOUT:   %CallGOnInitializingExpression: <function> = fn_decl @CallGOnInitializingExpression
+// CHECK:STDOUT:   %CallFOnInitializingExpr: <function> = fn_decl @CallFOnInitializingExpr
+// CHECK:STDOUT:   %CallGOnInitializingExpr: <function> = fn_decl @CallGOnInitializingExpr
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
 // CHECK:STDOUT: class @Class {
@@ -135,7 +135,7 @@ fn CallGOnInitializingExpression() -> i32 {
 // CHECK:STDOUT:
 // CHECK:STDOUT: fn @Make() -> %return: Class;
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @CallFOnInitializingExpression() -> i32 {
+// CHECK:STDOUT: fn @CallFOnInitializingExpr() -> i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %Make.ref: <function> = name_reference Make, file.%Make
 // CHECK:STDOUT:   %.loc40_14.1: ref Class = temporary_storage
@@ -149,7 +149,7 @@ fn CallGOnInitializingExpression() -> i32 {
 // CHECK:STDOUT:   return %.loc40_20.2
 // CHECK:STDOUT: }
 // CHECK:STDOUT:
-// CHECK:STDOUT: fn @CallGOnInitializingExpression() -> i32 {
+// CHECK:STDOUT: fn @CallGOnInitializingExpr() -> i32 {
 // CHECK:STDOUT: !entry:
 // CHECK:STDOUT:   %Make.ref: <function> = name_reference Make, file.%Make
 // CHECK:STDOUT:   %.loc44_14.1: ref Class = temporary_storage

toolchain/diagnostics/diagnostic_kind.def

@@ -62,18 +62,18 @@ CARBON_DIAGNOSTIC_KIND(BinaryOperatorRequiresWhitespace)
 CARBON_DIAGNOSTIC_KIND(ExpectedArraySemi)
 CARBON_DIAGNOSTIC_KIND(ExpectedCloseSymbol)
 CARBON_DIAGNOSTIC_KIND(ExpectedCodeBlock)
-CARBON_DIAGNOSTIC_KIND(ExpectedExpression)
+CARBON_DIAGNOSTIC_KIND(ExpectedExpr)
 CARBON_DIAGNOSTIC_KIND(ExpectedIdentifierAfterDotOrArrow)
 CARBON_DIAGNOSTIC_KIND(ExpectedLetBindingName)
 CARBON_DIAGNOSTIC_KIND(ExpectedParameterName)
 CARBON_DIAGNOSTIC_KIND(ExpectedParenAfter)
-CARBON_DIAGNOSTIC_KIND(ExpectedExpressionSemi)
+CARBON_DIAGNOSTIC_KIND(ExpectedExprSemi)
 CARBON_DIAGNOSTIC_KIND(ExpectedStatementSemi)
 CARBON_DIAGNOSTIC_KIND(ExpectedStructLiteralField)
 CARBON_DIAGNOSTIC_KIND(ExpectedVariableDeclaration)
 CARBON_DIAGNOSTIC_KIND(ExpectedVariableName)
 CARBON_DIAGNOSTIC_KIND(OperatorRequiresParentheses)
-CARBON_DIAGNOSTIC_KIND(StatementOperatorAsSubexpression)
+CARBON_DIAGNOSTIC_KIND(StatementOperatorAsSubexpr)
 CARBON_DIAGNOSTIC_KIND(UnaryOperatorRequiresParentheses)
 CARBON_DIAGNOSTIC_KIND(UnaryOperatorHasWhitespace)
 CARBON_DIAGNOSTIC_KIND(UnaryOperatorRequiresWhitespace)
@@ -126,7 +126,7 @@ CARBON_DIAGNOSTIC_KIND(AddressOfEphemeralReference)
 CARBON_DIAGNOSTIC_KIND(AddressOfNonReference)
 CARBON_DIAGNOSTIC_KIND(AddrOnNonSelfParameter)
 CARBON_DIAGNOSTIC_KIND(ArrayInitFromLiteralArgCountMismatch)
-CARBON_DIAGNOSTIC_KIND(ArrayInitFromExpressionArgCountMismatch)
+CARBON_DIAGNOSTIC_KIND(ArrayInitFromExprArgCountMismatch)
 CARBON_DIAGNOSTIC_KIND(AssignmentToNonAssignable)
 CARBON_DIAGNOSTIC_KIND(BreakOutsideLoop)
 CARBON_DIAGNOSTIC_KIND(ClassForwardDeclaredHere)
@@ -152,7 +152,7 @@ CARBON_DIAGNOSTIC_KIND(IncompleteTypeInLetDeclaration)
 CARBON_DIAGNOSTIC_KIND(IncompleteTypeInMemberAccess)
 CARBON_DIAGNOSTIC_KIND(IncompleteTypeInValueConversion)
 CARBON_DIAGNOSTIC_KIND(IncompleteTypeInVarDeclaration)
-CARBON_DIAGNOSTIC_KIND(InvalidArrayExpression)
+CARBON_DIAGNOSTIC_KIND(InvalidArrayExpr)
 CARBON_DIAGNOSTIC_KIND(TypeNotIndexable)
 CARBON_DIAGNOSTIC_KIND(IndexOutOfBounds)
 CARBON_DIAGNOSTIC_KIND(InvalidMainRunSignature)
@@ -162,19 +162,19 @@ CARBON_DIAGNOSTIC_KIND(StructInitMissingFieldInLiteral)
 CARBON_DIAGNOSTIC_KIND(StructInitMissingFieldInConversion)
 CARBON_DIAGNOSTIC_KIND(TupleIndexIntegerLiteral)
 CARBON_DIAGNOSTIC_KIND(TupleInitElementCountMismatch)
-CARBON_DIAGNOSTIC_KIND(ReturnStatementDisallowExpression)
+CARBON_DIAGNOSTIC_KIND(ReturnStatementDisallowExpr)
 CARBON_DIAGNOSTIC_KIND(ReturnStatementImplicitNote)
-CARBON_DIAGNOSTIC_KIND(ReturnStatementMissingExpression)
+CARBON_DIAGNOSTIC_KIND(ReturnStatementMissingExpr)
 CARBON_DIAGNOSTIC_KIND(ImplicitAsConversionFailure)
 CARBON_DIAGNOSTIC_KIND(ExplicitAsConversionFailure)
-CARBON_DIAGNOSTIC_KIND(TypeExpressionEvaluationFailure)
+CARBON_DIAGNOSTIC_KIND(TypeExprEvaluationFailure)
 CARBON_DIAGNOSTIC_KIND(QualifiedDeclarationInIncompleteClassScope)
 CARBON_DIAGNOSTIC_KIND(QualifiedDeclarationInNonScope)
 CARBON_DIAGNOSTIC_KIND(QualifiedDeclarationNonScopeEntity)
-CARBON_DIAGNOSTIC_KIND(QualifiedExpressionInIncompleteClassScope)
-CARBON_DIAGNOSTIC_KIND(QualifiedExpressionUnsupported)
-CARBON_DIAGNOSTIC_KIND(QualifiedExpressionNameNotFound)
-CARBON_DIAGNOSTIC_KIND(UseOfNonExpressionAsValue)
+CARBON_DIAGNOSTIC_KIND(QualifiedExprInIncompleteClassScope)
+CARBON_DIAGNOSTIC_KIND(QualifiedExprUnsupported)
+CARBON_DIAGNOSTIC_KIND(QualifiedExprNameNotFound)
+CARBON_DIAGNOSTIC_KIND(UseOfNonExprAsValue)
 
 // ============================================================================
 // Other diagnostics

toolchain/lower/handle.cpp

@@ -248,8 +248,8 @@ auto HandleReturn(FunctionContext& context, SemIR::InstId /*inst_id*/,
   context.builder().CreateRetVoid();
 }
 
-auto HandleReturnExpression(FunctionContext& context, SemIR::InstId /*inst_id*/,
-                            SemIR::ReturnExpression inst) -> void {
+auto HandleReturnExpr(FunctionContext& context, SemIR::InstId /*inst_id*/,
+                      SemIR::ReturnExpr inst) -> void {
   switch (SemIR::GetInitializingRepresentation(
               context.sem_ir(),
               context.sem_ir().insts().Get(inst.expr_id).type_id())

toolchain/lower/handle_aggregates.cpp

@@ -30,14 +30,14 @@ static auto GetAggregateElement(FunctionContext& context,
   auto aggr_inst = context.sem_ir().insts().Get(aggr_inst_id);
   auto* aggr_value = context.GetValue(aggr_inst_id);
 
-  switch (SemIR::GetExpressionCategory(context.sem_ir(), aggr_inst_id)) {
-    case SemIR::ExpressionCategory::Error:
-    case SemIR::ExpressionCategory::NotExpression:
-    case SemIR::ExpressionCategory::Initializing:
-    case SemIR::ExpressionCategory::Mixed:
+  switch (SemIR::GetExprCategory(context.sem_ir(), aggr_inst_id)) {
+    case SemIR::ExprCategory::Error:
+    case SemIR::ExprCategory::NotExpr:
+    case SemIR::ExprCategory::Initializing:
+    case SemIR::ExprCategory::Mixed:
       CARBON_FATAL() << "Unexpected expression category for aggregate access";
 
-    case SemIR::ExpressionCategory::Value: {
+    case SemIR::ExprCategory::Value: {
       auto value_rep =
           SemIR::GetValueRepresentation(context.sem_ir(), aggr_inst.type_id());
       CARBON_CHECK(value_rep.aggregate_kind !=
@@ -80,8 +80,8 @@ static auto GetAggregateElement(FunctionContext& context,
       }
     }
 
-    case SemIR::ExpressionCategory::DurableReference:
-    case SemIR::ExpressionCategory::EphemeralReference: {
+    case SemIR::ExprCategory::DurableReference:
+    case SemIR::ExprCategory::EphemeralReference: {
       // Just locate the aggregate element.
       auto* aggr_type = context.GetType(aggr_inst.type_id());
       return context.builder().CreateStructGEP(aggr_type, aggr_value, idx.index,

toolchain/lower/handle_expression_category.cpp

@@ -50,8 +50,8 @@ auto HandleTemporaryStorage(FunctionContext& context, SemIR::InstId inst_id,
 
 auto HandleValueAsReference(FunctionContext& context, SemIR::InstId inst_id,
                             SemIR::ValueAsReference inst) -> void {
-  CARBON_CHECK(SemIR::GetExpressionCategory(context.sem_ir(), inst.value_id) ==
-               SemIR::ExpressionCategory::Value);
+  CARBON_CHECK(SemIR::GetExprCategory(context.sem_ir(), inst.value_id) ==
+               SemIR::ExprCategory::Value);
   CARBON_CHECK(
       SemIR::GetValueRepresentation(context.sem_ir(), inst.type_id).kind ==
       SemIR::ValueRepresentation::Pointer);
@@ -60,8 +60,8 @@ auto HandleValueAsReference(FunctionContext& context, SemIR::InstId inst_id,
 
 auto HandleValueOfInitializer(FunctionContext& context, SemIR::InstId inst_id,
                               SemIR::ValueOfInitializer inst) -> void {
-  CARBON_CHECK(SemIR::GetExpressionCategory(context.sem_ir(), inst.init_id) ==
-               SemIR::ExpressionCategory::Initializing);
+  CARBON_CHECK(SemIR::GetExprCategory(context.sem_ir(), inst.init_id) ==
+               SemIR::ExprCategory::Initializing);
   CARBON_CHECK(
       SemIR::GetValueRepresentation(context.sem_ir(), inst.type_id).kind ==
       SemIR::ValueRepresentation::Copy);

toolchain/parse/context.cpp

@@ -144,8 +144,8 @@ auto Context::ConsumeIfPatternKeyword(Lex::TokenKind keyword_token,
     -> void {
   if (auto token = ConsumeIf(keyword_token)) {
     PushState(Context::StateStackEntry(
-        keyword_state, PrecedenceGroup::ForTopLevelExpression(),
-        PrecedenceGroup::ForTopLevelExpression(), *token, subtree_start));
+        keyword_state, PrecedenceGroup::ForTopLevelExpr(),
+        PrecedenceGroup::ForTopLevelExpr(), *token, subtree_start));
   }
 }
 

toolchain/parse/context.h

@@ -225,30 +225,29 @@ class Context {
 
   // Pushes a new state with the current position for context.
   auto PushState(State state) -> void {
-    PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpression(),
-                              PrecedenceGroup::ForTopLevelExpression(),
-                              *position_, tree_->size()));
+    PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpr(),
+                              PrecedenceGroup::ForTopLevelExpr(), *position_,
+                              tree_->size()));
   }
 
   // Pushes a new state with a specific token for context. Used when forming a
   // new subtree with a token that isn't the start of the subtree.
   auto PushState(State state, Lex::Token token) -> void {
-    PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpression(),
-                              PrecedenceGroup::ForTopLevelExpression(), token,
+    PushState(StateStackEntry(state, PrecedenceGroup::ForTopLevelExpr(),
+                              PrecedenceGroup::ForTopLevelExpr(), token,
                               tree_->size()));
   }
 
   // Pushes a new expression state with specific precedence.
-  auto PushStateForExpression(PrecedenceGroup ambient_precedence) -> void {
-    PushState(StateStackEntry(State::Expression, ambient_precedence,
-                              PrecedenceGroup::ForTopLevelExpression(),
-                              *position_, tree_->size()));
+  auto PushStateForExpr(PrecedenceGroup ambient_precedence) -> void {
+    PushState(StateStackEntry(State::Expr, ambient_precedence,
+                              PrecedenceGroup::ForTopLevelExpr(), *position_,
+                              tree_->size()));
   }
 
   // Pushes a new state with detailed precedence for expression resume states.
-  auto PushStateForExpressionLoop(State state,
-                                  PrecedenceGroup ambient_precedence,
-                                  PrecedenceGroup lhs_precedence) -> void {
+  auto PushStateForExprLoop(State state, PrecedenceGroup ambient_precedence,
+                            PrecedenceGroup lhs_precedence) -> void {
     PushState(StateStackEntry(state, ambient_precedence, lhs_precedence,
                               *position_, tree_->size()));
   }

toolchain/parse/handle_array_expression.cpp

@@ -10,40 +10,40 @@
 
 namespace Carbon::Parse {
 
-auto HandleArrayExpression(Context& context) -> void {
+auto HandleArrayExpr(Context& context) -> void {
   auto state = context.PopState();
-  state.state = State::ArrayExpressionSemi;
-  context.AddLeafNode(NodeKind::ArrayExpressionStart,
+  state.state = State::ArrayExprSemi;
+  context.AddLeafNode(NodeKind::ArrayExprStart,
                       context.ConsumeChecked(Lex::TokenKind::OpenSquareBracket),
                       state.has_error);
   context.PushState(state);
-  context.PushState(State::Expression);
+  context.PushState(State::Expr);
 }
 
-auto HandleArrayExpressionSemi(Context& context) -> void {
+auto HandleArrayExprSemi(Context& context) -> void {
   auto state = context.PopState();
   auto semi = context.ConsumeIf(Lex::TokenKind::Semi);
   if (!semi) {
-    context.AddNode(NodeKind::ArrayExpressionSemi, *context.position(),
+    context.AddNode(NodeKind::ArrayExprSemi, *context.position(),
                     state.subtree_start, true);
     CARBON_DIAGNOSTIC(ExpectedArraySemi, Error, "Expected `;` in array type.");
     context.emitter().Emit(*context.position(), ExpectedArraySemi);
     state.has_error = true;
   } else {
-    context.AddNode(NodeKind::ArrayExpressionSemi, *semi, state.subtree_start,
+    context.AddNode(NodeKind::ArrayExprSemi, *semi, state.subtree_start,
                     state.has_error);
   }
-  state.state = State::ArrayExpressionFinish;
+  state.state = State::ArrayExprFinish;
   context.PushState(state);
   if (!context.PositionIs(Lex::TokenKind::CloseSquareBracket)) {
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   }
 }
 
-auto HandleArrayExpressionFinish(Context& context) -> void {
+auto HandleArrayExprFinish(Context& context) -> void {
   auto state = context.PopState();
   context.ConsumeAndAddCloseSymbol(*(Lex::TokenIterator(state.token)), state,
-                                   NodeKind::ArrayExpression);
+                                   NodeKind::ArrayExpr);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_brace_expression.cpp

@@ -6,31 +6,28 @@
 
 namespace Carbon::Parse {
 
-auto HandleBraceExpression(Context& context) -> void {
+auto HandleBraceExpr(Context& context) -> void {
   auto state = context.PopState();
 
-  state.state = State::BraceExpressionFinishAsUnknown;
+  state.state = State::BraceExprFinishAsUnknown;
   context.PushState(state);
 
   CARBON_CHECK(context.ConsumeAndAddLeafNodeIf(
       Lex::TokenKind::OpenCurlyBrace,
       NodeKind::StructLiteralOrStructTypeLiteralStart));
   if (!context.PositionIs(Lex::TokenKind::CloseCurlyBrace)) {
-    context.PushState(State::BraceExpressionParameterAsUnknown);
+    context.PushState(State::BraceExprParameterAsUnknown);
   }
 }
 
 // Prints a diagnostic for brace expression syntax errors.
-static auto HandleBraceExpressionParameterError(Context& context,
-                                                Context::StateStackEntry state,
-                                                State param_finish_state)
-    -> void {
-  bool is_type =
-      param_finish_state == State::BraceExpressionParameterFinishAsType;
-  bool is_value =
-      param_finish_state == State::BraceExpressionParameterFinishAsValue;
+static auto HandleBraceExprParameterError(Context& context,
+                                          Context::StateStackEntry state,
+                                          State param_finish_state) -> void {
+  bool is_type = param_finish_state == State::BraceExprParameterFinishAsType;
+  bool is_value = param_finish_state == State::BraceExprParameterFinishAsValue;
   bool is_unknown =
-      param_finish_state == State::BraceExpressionParameterFinishAsUnknown;
+      param_finish_state == State::BraceExprParameterFinishAsUnknown;
   CARBON_CHECK(is_type || is_value || is_unknown);
   CARBON_DIAGNOSTIC(ExpectedStructLiteralField, Error, "Expected {0}{1}{2}.",
                     llvm::StringRef, llvm::StringRef, llvm::StringRef);
@@ -44,14 +41,14 @@ static auto HandleBraceExpressionParameterError(Context& context,
   context.PushState(state);
 }
 
-// Handles BraceExpressionParameterAs(Type|Value|Unknown).
-static auto HandleBraceExpressionParameter(Context& context,
-                                           State after_designator_state,
-                                           State param_finish_state) -> void {
+// Handles BraceExprParameterAs(Type|Value|Unknown).
+static auto HandleBraceExprParameter(Context& context,
+                                     State after_designator_state,
+                                     State param_finish_state) -> void {
   auto state = context.PopState();
 
   if (!context.PositionIs(Lex::TokenKind::Period)) {
-    HandleBraceExpressionParameterError(context, state, param_finish_state);
+    HandleBraceExprParameterError(context, state, param_finish_state);
     return;
   }
 
@@ -60,27 +57,28 @@ static auto HandleBraceExpressionParameter(Context& context,
   context.PushState(State::PeriodAsStruct);
 }
 
-auto HandleBraceExpressionParameterAsType(Context& context) -> void {
-  HandleBraceExpressionParameter(
-      context, State::BraceExpressionParameterAfterDesignatorAsType,
-      State::BraceExpressionParameterFinishAsType);
+auto HandleBraceExprParameterAsType(Context& context) -> void {
+  HandleBraceExprParameter(context,
+                           State::BraceExprParameterAfterDesignatorAsType,
+                           State::BraceExprParameterFinishAsType);
 }
 
-auto HandleBraceExpressionParameterAsValue(Context& context) -> void {
-  HandleBraceExpressionParameter(
-      context, State::BraceExpressionParameterAfterDesignatorAsValue,
-      State::BraceExpressionParameterFinishAsValue);
+auto HandleBraceExprParameterAsValue(Context& context) -> void {
+  HandleBraceExprParameter(context,
+                           State::BraceExprParameterAfterDesignatorAsValue,
+                           State::BraceExprParameterFinishAsValue);
 }
 
-auto HandleBraceExpressionParameterAsUnknown(Context& context) -> void {
-  HandleBraceExpressionParameter(
-      context, State::BraceExpressionParameterAfterDesignatorAsUnknown,
-      State::BraceExpressionParameterFinishAsUnknown);
+auto HandleBraceExprParameterAsUnknown(Context& context) -> void {
+  HandleBraceExprParameter(context,
+                           State::BraceExprParameterAfterDesignatorAsUnknown,
+                           State::BraceExprParameterFinishAsUnknown);
 }
 
-// Handles BraceExpressionParameterAfterDesignatorAs(Type|Value|Unknown).
-static auto HandleBraceExpressionParameterAfterDesignator(
-    Context& context, State param_finish_state) -> void {
+// Handles BraceExprParameterAfterDesignatorAs(Type|Value|Unknown).
+static auto HandleBraceExprParameterAfterDesignator(Context& context,
+                                                    State param_finish_state)
+    -> void {
   auto state = context.PopState();
 
   if (state.has_error) {
@@ -102,29 +100,29 @@ static auto HandleBraceExpressionParameterAfterDesignator(
   } else if (context.PositionIs(Lex::TokenKind::Equal)) {
     is_type = false;
   } else {
-    HandleBraceExpressionParameterError(context, state, param_finish_state);
+    HandleBraceExprParameterError(context, state, param_finish_state);
     return;
   }
 
   // If we're changing from unknown, update the related finish states.
-  if (param_finish_state == State::BraceExpressionParameterFinishAsUnknown) {
+  if (param_finish_state == State::BraceExprParameterFinishAsUnknown) {
     auto finish_state = context.PopState();
-    CARBON_CHECK(finish_state.state == State::BraceExpressionFinishAsUnknown);
+    CARBON_CHECK(finish_state.state == State::BraceExprFinishAsUnknown);
     if (is_type) {
-      finish_state.state = State::BraceExpressionFinishAsType;
-      param_finish_state = State::BraceExpressionParameterFinishAsType;
+      finish_state.state = State::BraceExprFinishAsType;
+      param_finish_state = State::BraceExprParameterFinishAsType;
     } else {
-      finish_state.state = State::BraceExpressionFinishAsValue;
-      param_finish_state = State::BraceExpressionParameterFinishAsValue;
+      finish_state.state = State::BraceExprFinishAsValue;
+      param_finish_state = State::BraceExprParameterFinishAsValue;
     }
     context.PushState(finish_state);
   }
 
-  auto want_param_finish_state =
-      is_type ? State::BraceExpressionParameterFinishAsType
-              : State::BraceExpressionParameterFinishAsValue;
+  auto want_param_finish_state = is_type
+                                     ? State::BraceExprParameterFinishAsType
+                                     : State::BraceExprParameterFinishAsValue;
   if (param_finish_state != want_param_finish_state) {
-    HandleBraceExpressionParameterError(context, state, param_finish_state);
+    HandleBraceExprParameterError(context, state, param_finish_state);
     return;
   }
 
@@ -133,31 +131,28 @@ static auto HandleBraceExpressionParameterAfterDesignator(
   state.state = param_finish_state;
   state.token = context.Consume();
   context.PushState(state);
-  context.PushState(State::Expression);
+  context.PushState(State::Expr);
 }
 
-auto HandleBraceExpressionParameterAfterDesignatorAsType(Context& context)
-    -> void {
-  HandleBraceExpressionParameterAfterDesignator(
-      context, State::BraceExpressionParameterFinishAsType);
+auto HandleBraceExprParameterAfterDesignatorAsType(Context& context) -> void {
+  HandleBraceExprParameterAfterDesignator(
+      context, State::BraceExprParameterFinishAsType);
 }
 
-auto HandleBraceExpressionParameterAfterDesignatorAsValue(Context& context)
-    -> void {
-  HandleBraceExpressionParameterAfterDesignator(
-      context, State::BraceExpressionParameterFinishAsValue);
+auto HandleBraceExprParameterAfterDesignatorAsValue(Context& context) -> void {
+  HandleBraceExprParameterAfterDesignator(
+      context, State::BraceExprParameterFinishAsValue);
 }
 
-auto HandleBraceExpressionParameterAfterDesignatorAsUnknown(Context& context)
+auto HandleBraceExprParameterAfterDesignatorAsUnknown(Context& context)
     -> void {
-  HandleBraceExpressionParameterAfterDesignator(
-      context, State::BraceExpressionParameterFinishAsUnknown);
+  HandleBraceExprParameterAfterDesignator(
+      context, State::BraceExprParameterFinishAsUnknown);
 }
 
-// Handles BraceExpressionParameterFinishAs(Type|Value|Unknown).
-static auto HandleBraceExpressionParameterFinish(Context& context,
-                                                 NodeKind node_kind,
-                                                 State param_state) -> void {
+// Handles BraceExprParameterFinishAs(Type|Value|Unknown).
+static auto HandleBraceExprParameterFinish(Context& context, NodeKind node_kind,
+                                           State param_state) -> void {
   auto state = context.PopState();
 
   if (state.has_error) {
@@ -175,24 +170,23 @@ static auto HandleBraceExpressionParameterFinish(Context& context,
   }
 }
 
-auto HandleBraceExpressionParameterFinishAsType(Context& context) -> void {
-  HandleBraceExpressionParameterFinish(context, NodeKind::StructFieldType,
-                                       State::BraceExpressionParameterAsType);
+auto HandleBraceExprParameterFinishAsType(Context& context) -> void {
+  HandleBraceExprParameterFinish(context, NodeKind::StructFieldType,
+                                 State::BraceExprParameterAsType);
 }
 
-auto HandleBraceExpressionParameterFinishAsValue(Context& context) -> void {
-  HandleBraceExpressionParameterFinish(context, NodeKind::StructFieldValue,
-                                       State::BraceExpressionParameterAsValue);
+auto HandleBraceExprParameterFinishAsValue(Context& context) -> void {
+  HandleBraceExprParameterFinish(context, NodeKind::StructFieldValue,
+                                 State::BraceExprParameterAsValue);
 }
 
-auto HandleBraceExpressionParameterFinishAsUnknown(Context& context) -> void {
-  HandleBraceExpressionParameterFinish(
-      context, NodeKind::StructFieldUnknown,
-      State::BraceExpressionParameterAsUnknown);
+auto HandleBraceExprParameterFinishAsUnknown(Context& context) -> void {
+  HandleBraceExprParameterFinish(context, NodeKind::StructFieldUnknown,
+                                 State::BraceExprParameterAsUnknown);
 }
 
-// Handles BraceExpressionFinishAs(Type|Value|Unknown).
-static auto HandleBraceExpressionFinish(Context& context, NodeKind node_kind)
+// Handles BraceExprFinishAs(Type|Value|Unknown).
+static auto HandleBraceExprFinish(Context& context, NodeKind node_kind)
     -> void {
   auto state = context.PopState();
 
@@ -200,16 +194,16 @@ static auto HandleBraceExpressionFinish(Context& context, NodeKind node_kind)
                   state.has_error);
 }
 
-auto HandleBraceExpressionFinishAsType(Context& context) -> void {
-  HandleBraceExpressionFinish(context, NodeKind::StructTypeLiteral);
+auto HandleBraceExprFinishAsType(Context& context) -> void {
+  HandleBraceExprFinish(context, NodeKind::StructTypeLiteral);
 }
 
-auto HandleBraceExpressionFinishAsValue(Context& context) -> void {
-  HandleBraceExpressionFinish(context, NodeKind::StructLiteral);
+auto HandleBraceExprFinishAsValue(Context& context) -> void {
+  HandleBraceExprFinish(context, NodeKind::StructLiteral);
 }
 
-auto HandleBraceExpressionFinishAsUnknown(Context& context) -> void {
-  HandleBraceExpressionFinish(context, NodeKind::StructLiteral);
+auto HandleBraceExprFinishAsUnknown(Context& context) -> void {
+  HandleBraceExprFinish(context, NodeKind::StructLiteral);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_call_expression.cpp

@@ -6,40 +6,40 @@
 
 namespace Carbon::Parse {
 
-auto HandleCallExpression(Context& context) -> void {
+auto HandleCallExpr(Context& context) -> void {
   auto state = context.PopState();
 
-  state.state = State::CallExpressionFinish;
+  state.state = State::CallExprFinish;
   context.PushState(state);
 
-  context.AddNode(NodeKind::CallExpressionStart, context.Consume(),
+  context.AddNode(NodeKind::CallExprStart, context.Consume(),
                   state.subtree_start, state.has_error);
   if (!context.PositionIs(Lex::TokenKind::CloseParen)) {
-    context.PushState(State::CallExpressionParameterFinish);
-    context.PushState(State::Expression);
+    context.PushState(State::CallExprParameterFinish);
+    context.PushState(State::Expr);
   }
 }
 
-auto HandleCallExpressionParameterFinish(Context& context) -> void {
+auto HandleCallExprParameterFinish(Context& context) -> void {
   auto state = context.PopState();
 
   if (state.has_error) {
     context.ReturnErrorOnState();
   }
 
-  if (context.ConsumeListToken(NodeKind::CallExpressionComma,
+  if (context.ConsumeListToken(NodeKind::CallExprComma,
                                Lex::TokenKind::CloseParen, state.has_error) ==
       Context::ListTokenKind::Comma) {
-    context.PushState(State::CallExpressionParameterFinish);
-    context.PushState(State::Expression);
+    context.PushState(State::CallExprParameterFinish);
+    context.PushState(State::Expr);
   }
 }
 
-auto HandleCallExpressionFinish(Context& context) -> void {
+auto HandleCallExprFinish(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::CallExpression, context.Consume(),
-                  state.subtree_start, state.has_error);
+  context.AddNode(NodeKind::CallExpr, context.Consume(), state.subtree_start,
+                  state.has_error);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_expression.cpp

@@ -6,15 +6,15 @@
 
 namespace Carbon::Parse {
 
-static auto DiagnoseStatementOperatorAsSubexpression(Context& context) -> void {
-  CARBON_DIAGNOSTIC(StatementOperatorAsSubexpression, Error,
+static auto DiagnoseStatementOperatorAsSubexpr(Context& context) -> void {
+  CARBON_DIAGNOSTIC(StatementOperatorAsSubexpr, Error,
                     "Operator `{0}` can only be used as a complete statement.",
                     Lex::TokenKind);
-  context.emitter().Emit(*context.position(), StatementOperatorAsSubexpression,
+  context.emitter().Emit(*context.position(), StatementOperatorAsSubexpr,
                          context.PositionKind());
 }
 
-auto HandleExpression(Context& context) -> void {
+auto HandleExpr(Context& context) -> void {
   auto state = context.PopState();
 
   // Check for a prefix operator.
@@ -25,7 +25,7 @@ auto HandleExpression(Context& context) -> void {
         OperatorPriority::RightFirst) {
       // The precedence rules don't permit this prefix operator in this
       // context. Diagnose this, but carry on and parse it anyway.
-      if (PrecedenceGroup::GetPriority(PrecedenceGroup::ForTopLevelExpression(),
+      if (PrecedenceGroup::GetPriority(PrecedenceGroup::ForTopLevelExpr(),
                                        *operator_precedence) ==
           OperatorPriority::RightFirst) {
         CARBON_DIAGNOSTIC(
@@ -37,7 +37,7 @@ auto HandleExpression(Context& context) -> void {
                                context.PositionKind());
       } else {
         // This operator wouldn't be allowed even if parenthesized.
-        DiagnoseStatementOperatorAsSubexpression(context);
+        DiagnoseStatementOperatorAsSubexpr(context);
       }
     } else {
       // Check that this operator follows the proper whitespace rules.
@@ -45,36 +45,35 @@ auto HandleExpression(Context& context) -> void {
     }
 
     if (context.PositionIs(Lex::TokenKind::If)) {
-      context.PushState(State::IfExpressionFinish);
-      context.PushState(State::IfExpressionFinishCondition);
+      context.PushState(State::IfExprFinish);
+      context.PushState(State::IfExprFinishCondition);
     } else {
-      context.PushStateForExpressionLoop(State::ExpressionLoopForPrefix,
-                                         state.ambient_precedence,
-                                         *operator_precedence);
+      context.PushStateForExprLoop(State::ExprLoopForPrefix,
+                                   state.ambient_precedence,
+                                   *operator_precedence);
     }
 
     ++context.position();
-    context.PushStateForExpression(*operator_precedence);
+    context.PushStateForExpr(*operator_precedence);
   } else {
-    context.PushStateForExpressionLoop(State::ExpressionLoop,
-                                       state.ambient_precedence,
-                                       PrecedenceGroup::ForPostfixExpression());
-    context.PushState(State::ExpressionInPostfix);
+    context.PushStateForExprLoop(State::ExprLoop, state.ambient_precedence,
+                                 PrecedenceGroup::ForPostfixExpr());
+    context.PushState(State::ExprInPostfix);
   }
 }
 
-auto HandleExpressionInPostfix(Context& context) -> void {
+auto HandleExprInPostfix(Context& context) -> void {
   auto state = context.PopState();
 
   // Continue to the loop state.
-  state.state = State::ExpressionInPostfixLoop;
+  state.state = State::ExprInPostfixLoop;
 
   // Parses a primary expression, which is either a terminal portion of an
   // expression tree, such as an identifier or literal, or a parenthesized
   // expression.
   switch (context.PositionKind()) {
     case Lex::TokenKind::Identifier: {
-      context.AddLeafNode(NodeKind::NameExpression, context.Consume());
+      context.AddLeafNode(NodeKind::NameExpr, context.Consume());
       context.PushState(state);
       break;
     }
@@ -95,26 +94,26 @@ auto HandleExpressionInPostfix(Context& context) -> void {
     }
     case Lex::TokenKind::OpenCurlyBrace: {
       context.PushState(state);
-      context.PushState(State::BraceExpression);
+      context.PushState(State::BraceExpr);
       break;
     }
     case Lex::TokenKind::OpenParen: {
       context.PushState(state);
-      context.PushState(State::ParenExpression);
+      context.PushState(State::ParenExpr);
       break;
     }
     case Lex::TokenKind::OpenSquareBracket: {
       context.PushState(state);
-      context.PushState(State::ArrayExpression);
+      context.PushState(State::ArrayExpr);
       break;
     }
     case Lex::TokenKind::SelfValueIdentifier: {
-      context.AddLeafNode(NodeKind::SelfValueNameExpression, context.Consume());
+      context.AddLeafNode(NodeKind::SelfValueNameExpr, context.Consume());
       context.PushState(state);
       break;
     }
     case Lex::TokenKind::SelfTypeIdentifier: {
-      context.AddLeafNode(NodeKind::SelfTypeNameExpression, context.Consume());
+      context.AddLeafNode(NodeKind::SelfTypeNameExpr, context.Consume());
       context.PushState(state);
       break;
     }
@@ -122,15 +121,15 @@ auto HandleExpressionInPostfix(Context& context) -> void {
       // Add a node to keep the parse tree balanced.
       context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
                           /*has_error=*/true);
-      CARBON_DIAGNOSTIC(ExpectedExpression, Error, "Expected expression.");
-      context.emitter().Emit(*context.position(), ExpectedExpression);
+      CARBON_DIAGNOSTIC(ExpectedExpr, Error, "Expected expression.");
+      context.emitter().Emit(*context.position(), ExpectedExpr);
       context.ReturnErrorOnState();
       break;
     }
   }
 }
 
-auto HandleExpressionInPostfixLoop(Context& context) -> void {
+auto HandleExprInPostfixLoop(Context& context) -> void {
   // This is a cyclic state that repeats, so this state is typically pushed back
   // on.
   auto state = context.PopState();
@@ -138,25 +137,25 @@ auto HandleExpressionInPostfixLoop(Context& context) -> void {
   switch (context.PositionKind()) {
     case Lex::TokenKind::Period: {
       context.PushState(state);
-      state.state = State::PeriodAsExpression;
+      state.state = State::PeriodAsExpr;
       context.PushState(state);
       break;
     }
     case Lex::TokenKind::MinusGreater: {
       context.PushState(state);
-      state.state = State::ArrowExpression;
+      state.state = State::ArrowExpr;
       context.PushState(state);
       break;
     }
     case Lex::TokenKind::OpenParen: {
       context.PushState(state);
-      state.state = State::CallExpression;
+      state.state = State::CallExpr;
       context.PushState(state);
       break;
     }
     case Lex::TokenKind::OpenSquareBracket: {
       context.PushState(state);
-      state.state = State::IndexExpression;
+      state.state = State::IndexExpr;
       context.PushState(state);
       break;
     }
@@ -169,7 +168,7 @@ auto HandleExpressionInPostfixLoop(Context& context) -> void {
   }
 }
 
-auto HandleExpressionLoop(Context& context) -> void {
+auto HandleExprLoop(Context& context) -> void {
   auto state = context.PopState();
 
   auto operator_kind = context.PositionKind();
@@ -202,7 +201,7 @@ auto HandleExpressionLoop(Context& context) -> void {
     // Either the LHS operator and this operator are ambiguous, or the
     // LHS operator is a unary operator that can't be nested within
     // this operator. Either way, parentheses are required.
-    if (PrecedenceGroup::GetPriority(PrecedenceGroup::ForTopLevelExpression(),
+    if (PrecedenceGroup::GetPriority(PrecedenceGroup::ForTopLevelExpr(),
                                      operator_precedence) ==
         OperatorPriority::RightFirst) {
       CARBON_DIAGNOSTIC(
@@ -211,7 +210,7 @@ auto HandleExpressionLoop(Context& context) -> void {
       context.emitter().Emit(*context.position(), OperatorRequiresParentheses);
     } else {
       // This operator wouldn't be allowed even if parenthesized.
-      DiagnoseStatementOperatorAsSubexpression(context);
+      DiagnoseStatementOperatorAsSubexpr(context);
     }
     state.has_error = true;
   } else {
@@ -232,9 +231,9 @@ auto HandleExpressionLoop(Context& context) -> void {
                       state.subtree_start, state.has_error);
     }
 
-    state.state = State::ExpressionLoopForBinary;
+    state.state = State::ExprLoopForBinary;
     context.PushState(state);
-    context.PushStateForExpression(operator_precedence);
+    context.PushStateForExpr(operator_precedence);
   } else {
     context.AddNode(NodeKind::PostfixOperator, state.token, state.subtree_start,
                     state.has_error);
@@ -243,37 +242,36 @@ auto HandleExpressionLoop(Context& context) -> void {
   }
 }
 
-auto HandleExpressionLoopForBinary(Context& context) -> void {
+auto HandleExprLoopForBinary(Context& context) -> void {
   auto state = context.PopState();
 
   context.AddNode(NodeKind::InfixOperator, state.token, state.subtree_start,
                   state.has_error);
-  state.state = State::ExpressionLoop;
+  state.state = State::ExprLoop;
   state.has_error = false;
   context.PushState(state);
 }
 
-auto HandleExpressionLoopForPrefix(Context& context) -> void {
+auto HandleExprLoopForPrefix(Context& context) -> void {
   auto state = context.PopState();
 
   context.AddNode(NodeKind::PrefixOperator, state.token, state.subtree_start,
                   state.has_error);
-  state.state = State::ExpressionLoop;
+  state.state = State::ExprLoop;
   state.has_error = false;
   context.PushState(state);
 }
 
-auto HandleIfExpressionFinishCondition(Context& context) -> void {
+auto HandleIfExprFinishCondition(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::IfExpressionIf, state.token, state.subtree_start,
+  context.AddNode(NodeKind::IfExprIf, state.token, state.subtree_start,
                   state.has_error);
 
   if (context.PositionIs(Lex::TokenKind::Then)) {
-    context.PushState(State::IfExpressionFinishThen);
+    context.PushState(State::IfExprFinishThen);
     context.ConsumeChecked(Lex::TokenKind::Then);
-    context.PushStateForExpression(
-        *PrecedenceGroup::ForLeading(Lex::TokenKind::If));
+    context.PushStateForExpr(*PrecedenceGroup::ForLeading(Lex::TokenKind::If));
   } else {
     // TODO: Include the location of the `if` token.
     CARBON_DIAGNOSTIC(ExpectedThenAfterIf, Error,
@@ -281,7 +279,7 @@ auto HandleIfExpressionFinishCondition(Context& context) -> void {
     if (!state.has_error) {
       context.emitter().Emit(*context.position(), ExpectedThenAfterIf);
     }
-    // Add placeholders for `IfExpressionThen` and final `Expression`.
+    // Add placeholders for `IfExprThen` and final `Expr`.
     context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
                         /*has_error=*/true);
     context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
@@ -290,17 +288,16 @@ auto HandleIfExpressionFinishCondition(Context& context) -> void {
   }
 }
 
-auto HandleIfExpressionFinishThen(Context& context) -> void {
+auto HandleIfExprFinishThen(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::IfExpressionThen, state.token, state.subtree_start,
+  context.AddNode(NodeKind::IfExprThen, state.token, state.subtree_start,
                   state.has_error);
 
   if (context.PositionIs(Lex::TokenKind::Else)) {
-    context.PushState(State::IfExpressionFinishElse);
+    context.PushState(State::IfExprFinishElse);
     context.ConsumeChecked(Lex::TokenKind::Else);
-    context.PushStateForExpression(
-        *PrecedenceGroup::ForLeading(Lex::TokenKind::If));
+    context.PushStateForExpr(*PrecedenceGroup::ForLeading(Lex::TokenKind::If));
   } else {
     // TODO: Include the location of the `if` token.
     CARBON_DIAGNOSTIC(ExpectedElseAfterIf, Error,
@@ -308,14 +305,14 @@ auto HandleIfExpressionFinishThen(Context& context) -> void {
     if (!state.has_error) {
       context.emitter().Emit(*context.position(), ExpectedElseAfterIf);
     }
-    // Add placeholder for the final `Expression`.
+    // Add placeholder for the final `Expr`.
     context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
                         /*has_error=*/true);
     context.ReturnErrorOnState();
   }
 }
 
-auto HandleIfExpressionFinishElse(Context& context) -> void {
+auto HandleIfExprFinishElse(Context& context) -> void {
   auto else_state = context.PopState();
 
   // Propagate the location of `else`.
@@ -325,31 +322,30 @@ auto HandleIfExpressionFinishElse(Context& context) -> void {
   context.PushState(if_state);
 }
 
-auto HandleIfExpressionFinish(Context& context) -> void {
+auto HandleIfExprFinish(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::IfExpressionElse, state.token, state.subtree_start,
+  context.AddNode(NodeKind::IfExprElse, state.token, state.subtree_start,
                   state.has_error);
 }
 
-auto HandleExpressionStatementFinish(Context& context) -> void {
+auto HandleExprStatementFinish(Context& context) -> void {
   auto state = context.PopState();
 
   if (auto semi = context.ConsumeIf(Lex::TokenKind::Semi)) {
-    context.AddNode(NodeKind::ExpressionStatement, *semi, state.subtree_start,
+    context.AddNode(NodeKind::ExprStatement, *semi, state.subtree_start,
                     state.has_error);
     return;
   }
 
   if (!state.has_error) {
-    CARBON_DIAGNOSTIC(ExpectedExpressionSemi, Error,
+    CARBON_DIAGNOSTIC(ExpectedExprSemi, Error,
                       "Expected `;` after expression statement.");
-    context.emitter().Emit(*context.position(), ExpectedExpressionSemi);
+    context.emitter().Emit(*context.position(), ExpectedExprSemi);
   }
 
   if (auto semi_token = context.SkipPastLikelyEnd(state.token)) {
-    context.AddNode(NodeKind::ExpressionStatement, *semi_token,
-                    state.subtree_start,
+    context.AddNode(NodeKind::ExprStatement, *semi_token, state.subtree_start,
                     /*has_error=*/true);
     return;
   }

toolchain/parse/handle_function.cpp

@@ -28,7 +28,7 @@ auto HandleFunctionAfterParameters(Context& context) -> void {
   if (context.PositionIs(Lex::TokenKind::MinusGreater)) {
     context.PushState(State::FunctionReturnTypeFinish);
     ++context.position();
-    context.PushStateForExpression(PrecedenceGroup::ForType());
+    context.PushStateForExpr(PrecedenceGroup::ForType());
   }
 }
 

toolchain/parse/handle_index_expression.cpp

@@ -7,21 +7,20 @@
 
 namespace Carbon::Parse {
 
-auto HandleIndexExpression(Context& context) -> void {
+auto HandleIndexExpr(Context& context) -> void {
   auto state = context.PopState();
-  state.state = State::IndexExpressionFinish;
+  state.state = State::IndexExprFinish;
   context.PushState(state);
-  context.AddNode(NodeKind::IndexExpressionStart,
+  context.AddNode(NodeKind::IndexExprStart,
                   context.ConsumeChecked(Lex::TokenKind::OpenSquareBracket),
                   state.subtree_start, state.has_error);
-  context.PushState(State::Expression);
+  context.PushState(State::Expr);
 }
 
-auto HandleIndexExpressionFinish(Context& context) -> void {
+auto HandleIndexExprFinish(Context& context) -> void {
   auto state = context.PopState();
 
-  context.ConsumeAndAddCloseSymbol(state.token, state,
-                                   NodeKind::IndexExpression);
+  context.ConsumeAndAddCloseSymbol(state.token, state, NodeKind::IndexExpr);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_let.cpp

@@ -31,7 +31,7 @@ auto HandleLetAfterPattern(Context& context) -> void {
 
   if (auto equals = context.ConsumeIf(Lex::TokenKind::Equal)) {
     context.AddLeafNode(NodeKind::LetInitializer, *equals);
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   } else if (!state.has_error) {
     CARBON_DIAGNOSTIC(
         ExpectedInitializerAfterLet, Error,

toolchain/parse/handle_paren_condition.cpp

@@ -26,7 +26,7 @@ static auto HandleParenCondition(Context& context, NodeKind start_kind,
     context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
                         /*has_error=*/true);
   } else {
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   }
 }
 

toolchain/parse/handle_paren_expression.cpp

@@ -6,27 +6,27 @@
 
 namespace Carbon::Parse {
 
-auto HandleParenExpression(Context& context) -> void {
+auto HandleParenExpr(Context& context) -> void {
   auto state = context.PopState();
 
   // Advance past the open paren.
-  context.AddLeafNode(NodeKind::ParenExpressionOrTupleLiteralStart,
+  context.AddLeafNode(NodeKind::ParenExprOrTupleLiteralStart,
                       context.ConsumeChecked(Lex::TokenKind::OpenParen));
 
   if (context.PositionIs(Lex::TokenKind::CloseParen)) {
-    state.state = State::ParenExpressionFinishAsTuple;
+    state.state = State::ParenExprFinishAsTuple;
     context.PushState(state);
   } else {
-    state.state = State::ParenExpressionFinishAsNormal;
+    state.state = State::ParenExprFinishAsNormal;
     context.PushState(state);
-    context.PushState(State::ParenExpressionParameterFinishAsUnknown);
-    context.PushState(State::Expression);
+    context.PushState(State::ParenExprParameterFinishAsUnknown);
+    context.PushState(State::Expr);
   }
 }
 
-// Handles ParenExpressionParameterFinishAs(Unknown|Tuple).
-static auto HandleParenExpressionParameterFinish(Context& context,
-                                                 bool as_tuple) -> void {
+// Handles ParenExprParameterFinishAs(Unknown|Tuple).
+static auto HandleParenExprParameterFinish(Context& context, bool as_tuple)
+    -> void {
   auto state = context.PopState();
 
   auto list_token_kind = context.ConsumeListToken(
@@ -39,38 +39,38 @@ static auto HandleParenExpressionParameterFinish(Context& context,
   // Note this could be `(expr,)` so we may not reuse the current state, but
   // it's still necessary to switch the parent.
   if (!as_tuple) {
-    state.state = State::ParenExpressionParameterFinishAsTuple;
+    state.state = State::ParenExprParameterFinishAsTuple;
 
     auto finish_state = context.PopState();
-    CARBON_CHECK(finish_state.state == State::ParenExpressionFinishAsNormal)
+    CARBON_CHECK(finish_state.state == State::ParenExprFinishAsNormal)
         << "Unexpected parent state, found: " << finish_state.state;
-    finish_state.state = State::ParenExpressionFinishAsTuple;
+    finish_state.state = State::ParenExprFinishAsTuple;
     context.PushState(finish_state);
   }
 
   // On a comma, push another expression handler.
   if (list_token_kind == Context::ListTokenKind::Comma) {
     context.PushState(state);
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   }
 }
 
-auto HandleParenExpressionParameterFinishAsUnknown(Context& context) -> void {
-  HandleParenExpressionParameterFinish(context, /*as_tuple=*/false);
+auto HandleParenExprParameterFinishAsUnknown(Context& context) -> void {
+  HandleParenExprParameterFinish(context, /*as_tuple=*/false);
 }
 
-auto HandleParenExpressionParameterFinishAsTuple(Context& context) -> void {
-  HandleParenExpressionParameterFinish(context, /*as_tuple=*/true);
+auto HandleParenExprParameterFinishAsTuple(Context& context) -> void {
+  HandleParenExprParameterFinish(context, /*as_tuple=*/true);
 }
 
-auto HandleParenExpressionFinishAsNormal(Context& context) -> void {
+auto HandleParenExprFinishAsNormal(Context& context) -> void {
   auto state = context.PopState();
 
-  context.AddNode(NodeKind::ParenExpression, context.Consume(),
-                  state.subtree_start, state.has_error);
+  context.AddNode(NodeKind::ParenExpr, context.Consume(), state.subtree_start,
+                  state.has_error);
 }
 
-auto HandleParenExpressionFinishAsTuple(Context& context) -> void {
+auto HandleParenExprFinishAsTuple(Context& context) -> void {
   auto state = context.PopState();
 
   context.AddNode(NodeKind::TupleLiteral, context.Consume(),

toolchain/parse/handle_pattern.cpp

@@ -78,7 +78,7 @@ static auto HandlePattern(Context& context, Context::PatternKind pattern_kind)
     // Use the `:` or `:!` for the root node.
     state.token = context.Consume();
     context.PushState(state);
-    context.PushStateForExpression(PrecedenceGroup::ForType());
+    context.PushStateForExpr(PrecedenceGroup::ForType());
   } else {
     on_error();
     return;

toolchain/parse/handle_period.cpp

@@ -6,7 +6,7 @@
 
 namespace Carbon::Parse {
 
-// Handles PeriodAs variants and ArrowExpression.
+// Handles PeriodAs variants and ArrowExpr.
 // TODO: This currently only supports identifiers on the rhs, but will in the
 // future need to handle things like `object.(Interface.member)` for qualifiers.
 static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
@@ -46,8 +46,8 @@ auto HandlePeriodAsDeclaration(Context& context) -> void {
                       /*is_arrow=*/false);
 }
 
-auto HandlePeriodAsExpression(Context& context) -> void {
-  HandlePeriodOrArrow(context, NodeKind::MemberAccessExpression,
+auto HandlePeriodAsExpr(Context& context) -> void {
+  HandlePeriodOrArrow(context, NodeKind::MemberAccessExpr,
                       /*is_arrow=*/false);
 }
 
@@ -56,8 +56,8 @@ auto HandlePeriodAsStruct(Context& context) -> void {
                       /*is_arrow=*/false);
 }
 
-auto HandleArrowExpression(Context& context) -> void {
-  HandlePeriodOrArrow(context, NodeKind::PointerMemberAccessExpression,
+auto HandleArrowExpr(Context& context) -> void {
+  HandlePeriodOrArrow(context, NodeKind::PointerMemberAccessExpr,
                       /*is_arrow=*/true);
 }
 

toolchain/parse/handle_statement.cpp

@@ -47,8 +47,8 @@ auto HandleStatement(Context& context) -> void {
       break;
     }
     default: {
-      context.PushState(State::ExpressionStatementFinish);
-      context.PushStateForExpression(PrecedenceGroup::ForExpressionStatement());
+      context.PushState(State::ExprStatementFinish);
+      context.PushStateForExpr(PrecedenceGroup::ForExprStatement());
       break;
     }
   }
@@ -116,7 +116,7 @@ auto HandleStatementForHeaderIn(Context& context) -> void {
 
   state.state = State::StatementForHeaderFinish;
   context.PushState(state);
-  context.PushState(State::Expression);
+  context.PushState(State::Expr);
 }
 
 auto HandleStatementForHeaderFinish(Context& context) -> void {
@@ -180,7 +180,7 @@ auto HandleStatementReturn(Context& context) -> void {
 
   context.AddLeafNode(NodeKind::ReturnStatementStart, context.Consume());
   if (!context.PositionIs(Lex::TokenKind::Semi)) {
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   }
 }
 

toolchain/parse/handle_var.cpp

@@ -40,7 +40,7 @@ auto HandleVarAfterPattern(Context& context) -> void {
 
   if (auto equals = context.ConsumeIf(Lex::TokenKind::Equal)) {
     context.AddLeafNode(NodeKind::VariableInitializer, *equals);
-    context.PushState(State::Expression);
+    context.PushState(State::Expr);
   }
 }
 

toolchain/parse/node_kind.def

@@ -68,7 +68,7 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, 0,
                                        CARBON_IF_ERROR(CARBON_ANY_TOKEN))
 
 // A name in an expression context.
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(NameExpression, 0, CARBON_TOKEN(Identifier))
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(NameExpr, 0, CARBON_TOKEN(Identifier))
 
 // ----------------------------------------------------------------------------
 
@@ -170,7 +170,7 @@ CARBON_PARSE_NODE_KIND_BRACKET(FunctionDeclaration, FunctionIntroducer,
 //   ParameterListComma
 // [Implicit]ParameterList
 //
-// Expressions and ParameterListComma may repeat with ParameterListComma as a
+// Exprs and ParameterListComma may repeat with ParameterListComma as a
 // separator.
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParameterListStart, 0,
                                    CARBON_TOKEN(OpenParen))
@@ -179,21 +179,22 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(ImplicitParameterListStart, 0,
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParameterListComma, 0, CARBON_TOKEN(Comma))
 CARBON_PARSE_NODE_KIND_BRACKET(ParameterList, ParameterListStart,
                                CARBON_TOKEN(CloseParen))
-CARBON_PARSE_NODE_KIND_BRACKET(ImplicitParameterList, ImplicitParameterListStart,
+CARBON_PARSE_NODE_KIND_BRACKET(ImplicitParameterList,
+                               ImplicitParameterListStart,
                                CARBON_TOKEN(CloseSquareBracket))
 
 // An array type, such as  `[i32; 3]` or `[i32;]`:
-//     ArrayExpressionStart
+//     ArrayExprStart
 //     _external_: type expression
-//   ArrayExpressionSemi
+//   ArrayExprSemi
 //   _optional_ _external_: expression
-// ArrayExpression
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(ArrayExpressionStart, 0,
+// ArrayExpr
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(ArrayExprStart, 0,
                                    CARBON_TOKEN(OpenSquareBracket))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(
-    ArrayExpressionSemi, 2,
+    ArrayExprSemi, 2,
     CARBON_TOKEN(Semi) CARBON_IF_ERROR(CARBON_TOKEN(CloseSquareBracket)))
-CARBON_PARSE_NODE_KIND_BRACKET(ArrayExpression, ArrayExpressionSemi,
+CARBON_PARSE_NODE_KIND_BRACKET(ArrayExpr, ArrayExprSemi,
                                CARBON_TOKEN(CloseSquareBracket))
 
 // A pattern binding, such as `name: Type`:
@@ -239,8 +240,8 @@ CARBON_PARSE_NODE_KIND_BRACKET(VariableDeclaration, VariableIntroducer,
 
 // An expression statement:
 //   _external_: expression
-// ExpressionStatement
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(ExpressionStatement, 1, CARBON_TOKEN(Semi))
+// ExprStatement
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(ExprStatement, 1, CARBON_TOKEN(Semi))
 
 // `break`:
 //   BreakStatementStart
@@ -324,49 +325,47 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(WhileStatement, 2, CARBON_TOKEN(While))
 
 // Index expressions, such as `a[1]`:
 //     _external_: expression
-//   IndexExpressionStart
+//   IndexExprStart
 //   _external_: expression
-// IndexExpression
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(IndexExpressionStart, 1,
+// IndexExpr
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(IndexExprStart, 1,
                                    CARBON_TOKEN(OpenSquareBracket))
-CARBON_PARSE_NODE_KIND_BRACKET(IndexExpression, IndexExpressionStart,
+CARBON_PARSE_NODE_KIND_BRACKET(IndexExpr, IndexExprStart,
                                CARBON_TOKEN(CloseSquareBracket))
 
 // Parenthesized expressions, such as `(2)`:
-//   ParenExpressionOrTupleLiteralStart
+//   ParenExprOrTupleLiteralStart
 //   _external_: expression
-// ParenExpression
+// ParenExpr
 //
 // Tuples, such as `(1, 2)`:
-//   ParenExpressionOrTupleLiteralStart
+//   ParenExprOrTupleLiteralStart
 //   _external_: expression
 //   TupleLiteralComma
 // TupleLiteral
 //
-// Expressions and TupleLiteralComma may repeat with TupleLiteralComma as a
+// Exprs and TupleLiteralComma may repeat with TupleLiteralComma as a
 // separator.
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParenExpressionOrTupleLiteralStart, 0,
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParenExprOrTupleLiteralStart, 0,
                                    CARBON_TOKEN(OpenParen))
-CARBON_PARSE_NODE_KIND_BRACKET(ParenExpression,
-                               ParenExpressionOrTupleLiteralStart,
+CARBON_PARSE_NODE_KIND_BRACKET(ParenExpr, ParenExprOrTupleLiteralStart,
                                CARBON_TOKEN(CloseParen))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(TupleLiteralComma, 0, CARBON_TOKEN(Comma))
-CARBON_PARSE_NODE_KIND_BRACKET(TupleLiteral, ParenExpressionOrTupleLiteralStart,
+CARBON_PARSE_NODE_KIND_BRACKET(TupleLiteral, ParenExprOrTupleLiteralStart,
                                CARBON_TOKEN(CloseParen))
 
 // Call expressions, such as `a()`:
 //     _external_: expression
-//   CallExpressionStart
+//   CallExprStart
 //   _external_: expression
-//   CallExpressionComma
-// CallExpression
+//   CallExprComma
+// CallExpr
 //
-// Expressions and CallExpressionComma may repeat with CallExpressionComma as a
+// Exprs and CallExprComma may repeat with CallExprComma as a
 // separator.
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExpressionStart, 1,
-                                   CARBON_TOKEN(OpenParen))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExpressionComma, 0, CARBON_TOKEN(Comma))
-CARBON_PARSE_NODE_KIND_BRACKET(CallExpression, CallExpressionStart,
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExprStart, 1, CARBON_TOKEN(OpenParen))
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(CallExprComma, 0, CARBON_TOKEN(Comma))
+CARBON_PARSE_NODE_KIND_BRACKET(CallExpr, CallExprStart,
                                CARBON_TOKEN(CloseParen))
 
 // A qualified declaration, such as `a.b`:
@@ -383,16 +382,15 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(QualifiedDeclaration, 2,
 // `GetObject().(Interface.member)`:
 //   _external_: lhs expression
 //   _external_: rhs expression
-// QualifiedExpression
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(MemberAccessExpression, 2,
-                                   CARBON_TOKEN(Period))
+// QualifiedExpr
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(MemberAccessExpr, 2, CARBON_TOKEN(Period))
 
 // A pointer member access expression, such as `a->b` or
 // `GetObject()->(Interface.member)`:
 //   _external_: lhs expression
 //   _external_: rhs expression
-// QualifiedExpression
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(PointerMemberAccessExpression, 2,
+// QualifiedExpr
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(PointerMemberAccessExpr, 2,
                                    CARBON_TOKEN(MinusGreater))
 
 // clang-format off
@@ -477,14 +475,14 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(PostfixOperator, 1, CARBON_TOKEN(Star))
 
 // `if` expression + `then` + `else`:
 //     _external_: expression
-//   IfExpressionIf
+//   IfExprIf
 //     _external_: expression
-//   IfExpressionThen
+//   IfExprThen
 //   _external_: expression
-// IfExpressionElse
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionIf, 1, CARBON_TOKEN(If))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionThen, 1, CARBON_TOKEN(Then))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExpressionElse, 3,
+// IfExprElse
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExprIf, 1, CARBON_TOKEN(If))
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExprThen, 1, CARBON_TOKEN(Then))
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(IfExprElse, 3,
                                    CARBON_TOKEN(Else)
                                        CARBON_IF_ERROR(CARBON_TOKEN(If)))
 
@@ -590,14 +588,14 @@ CARBON_PARSE_NODE_KIND_BRACKET(NamedConstraintDeclaration,
 // The `self` value and `Self` type identifier keywords. Typically of the form
 // `self: Self`:
 //   SelfValueName
-//   SelfValueNameExpression
-//   SelfTypeNameExpression
+//   SelfValueNameExpr
+//   SelfTypeNameExpr
 // PatternBinding
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfValueName, 0,
                                    CARBON_TOKEN(SelfValueIdentifier))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfValueNameExpression, 0,
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfValueNameExpr, 0,
                                    CARBON_TOKEN(SelfValueIdentifier))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfTypeNameExpression, 0,
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(SelfTypeNameExpr, 0,
                                    CARBON_TOKEN(SelfTypeIdentifier))
 
 #undef CARBON_PARSE_NODE_KIND

toolchain/parse/precedence.cpp

@@ -177,21 +177,19 @@ struct OperatorPriorityTable {
 };
 }  // namespace
 
-auto PrecedenceGroup::ForPostfixExpression() -> PrecedenceGroup {
+auto PrecedenceGroup::ForPostfixExpr() -> PrecedenceGroup {
   return PrecedenceGroup(Highest);
 }
 
-auto PrecedenceGroup::ForTopLevelExpression() -> PrecedenceGroup {
+auto PrecedenceGroup::ForTopLevelExpr() -> PrecedenceGroup {
   return PrecedenceGroup(If);
 }
 
-auto PrecedenceGroup::ForExpressionStatement() -> PrecedenceGroup {
+auto PrecedenceGroup::ForExprStatement() -> PrecedenceGroup {
   return PrecedenceGroup(Lowest);
 }
 
-auto PrecedenceGroup::ForType() -> PrecedenceGroup {
-  return ForTopLevelExpression();
-}
+auto PrecedenceGroup::ForType() -> PrecedenceGroup { return ForTopLevelExpr(); }
 
 auto PrecedenceGroup::ForLeading(Lex::TokenKind kind)
     -> std::optional<PrecedenceGroup> {

toolchain/parse/precedence.h

@@ -39,16 +39,16 @@ class PrecedenceGroup {
 
   // Get the sentinel precedence level for a postfix expression. All operators
   // have lower precedence than this.
-  static auto ForPostfixExpression() -> PrecedenceGroup;
+  static auto ForPostfixExpr() -> PrecedenceGroup;
 
   // Get the precedence level for a top-level or parenthesized expression. All
   // expression operators have higher precedence than this.
-  static auto ForTopLevelExpression() -> PrecedenceGroup;
+  static auto ForTopLevelExpr() -> PrecedenceGroup;
 
   // Get the sentinel precedence level for a statement context. All operators,
   // including statement operators like `=` and `++`, have higher precedence
   // than this.
-  static auto ForExpressionStatement() -> PrecedenceGroup;
+  static auto ForExprStatement() -> PrecedenceGroup;
 
   // Get the precedence level at which to parse a type expression. All type
   // operators have higher precedence than this.

toolchain/parse/state.def

@@ -21,8 +21,8 @@
 // the stack.
 //
 // Where state output is conditional on a lexed token, the name of
-// the Lex::TokenKind should be used rather than the string name in order to make it
-// easier to compare with code.
+// the Lex::TokenKind should be used rather than the string name in order to
+// make it easier to compare with code.
 
 #ifndef CARBON_PARSE_STATE
 #error "Must define the x-macro to use this file."
@@ -38,115 +38,115 @@
 #define CARBON_PARSE_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \
   CARBON_PARSE_STATE_VARIANT(State, Variant1)                             \
   CARBON_PARSE_STATE_VARIANTS2(State, Variant2, Variant3)
-#define CARBON_PARSE_STATE_VARIANTS4(State, Variant1, Variant2, Variant3, Variant4) \
-  CARBON_PARSE_STATE_VARIANT(State, Variant1)                                       \
+#define CARBON_PARSE_STATE_VARIANTS4(State, Variant1, Variant2, Variant3, \
+                                     Variant4)                            \
+  CARBON_PARSE_STATE_VARIANT(State, Variant1)                             \
   CARBON_PARSE_STATE_VARIANTS3(State, Variant2, Variant3, Variant4)
 
 // Handles an index expression `a[0]`.
 //
 // Always:
-//   1. Expression
-//   2. IndexExpressionFinish
-CARBON_PARSE_STATE(IndexExpression)
+//   1. Expr
+//   2. IndexExprFinish
+CARBON_PARSE_STATE(IndexExpr)
 
 // Handles finishing the index expression.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(IndexExpressionFinish)
+CARBON_PARSE_STATE(IndexExprFinish)
 
 // Handles an array expression `[T; N]`.
 //
 // Always:
-//   1. Expression
-//   2. ArrayExpressionSemi
-CARBON_PARSE_STATE(ArrayExpression)
+//   1. Expr
+//   2. ArrayExprSemi
+CARBON_PARSE_STATE(ArrayExpr)
 
 // Handles ';' in an array expression `[T; N]`.
 //
 // If `CloseSquareBracket`:
-//   1. ArrayExpressionFinish
+//   1. ArrayExprFinish
 // Else:
-//   1. Expression
-//   2. ArrayExpressionFinish
-CARBON_PARSE_STATE(ArrayExpressionSemi)
+//   1. Expr
+//   2. ArrayExprFinish
+CARBON_PARSE_STATE(ArrayExprSemi)
 
 // Handles finishing the array expression.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(ArrayExpressionFinish)
+CARBON_PARSE_STATE(ArrayExprFinish)
 
 // Handles the `{` of a brace expression.
 //
 // If `CloseCurlyBrace`:
-//   1. BraceExpressionFinishAsUnknown
+//   1. BraceExprFinishAsUnknown
 // Else:
-//   1. BraceExpressionParameterAsUnknown
-//   2. BraceExpressionFinishAsUnknown
-CARBON_PARSE_STATE(BraceExpression)
+//   1. BraceExprParameterAsUnknown
+//   2. BraceExprFinishAsUnknown
+CARBON_PARSE_STATE(BraceExpr)
 
 // Handles a brace expression parameter. Note this will always start as unknown,
 // but should be known after the first valid parameter. All later inconsistent
 // parameters are invalid.
 //
 // If valid:
-//   1. DesignatorExpressionAsStruct
-//   2. BraceExpressionParameterAfterDesignatorAs(Type|Value|Unknown)
+//   1. DesignatorExprAsStruct
+//   2. BraceExprParameterAfterDesignatorAs(Type|Value|Unknown)
 // Else:
-//   1. BraceExpressionParameterFinishAs(Type|Value|Unknown)
-CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameter, Type, Value, Unknown)
+//   1. BraceExprParameterFinishAs(Type|Value|Unknown)
+CARBON_PARSE_STATE_VARIANTS3(BraceExprParameter, Type, Value, Unknown)
 
 // Handles a brace expression parameter after the initial designator. This
 // should be at a `:` or `=`, depending on whether it's a type or value literal.
 //
 // If valid:
-//   1. Expression
-//   2. BraceExpressionParameterFinishAs(Type|Value|Unknown)
+//   1. Expr
+//   2. BraceExprParameterFinishAs(Type|Value|Unknown)
 // Else:
-//   1. BraceExpressionParameterFinishAs(Type|Value|Unknown)
-CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameterAfterDesignator, Type,
-                              Value, Unknown)
+//   1. BraceExprParameterFinishAs(Type|Value|Unknown)
+CARBON_PARSE_STATE_VARIANTS3(BraceExprParameterAfterDesignator, Type, Value,
+                             Unknown)
 
 // Handles the end of a brace expression parameter.
 //
 // If `Comma`:
-//   1. BraceExpressionParameterAsUnknown
+//   1. BraceExprParameterAsUnknown
 // Else:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS3(BraceExpressionParameterFinish, Type, Value,
-                              Unknown)
+CARBON_PARSE_STATE_VARIANTS3(BraceExprParameterFinish, Type, Value, Unknown)
 
 // Handles the `}` of a brace expression.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS3(BraceExpressionFinish, Type, Value, Unknown)
+CARBON_PARSE_STATE_VARIANTS3(BraceExprFinish, Type, Value, Unknown)
 
 // Handles a call expression `(...)`.
 //
 // If `CloseParen`:
-//   1. CallExpressionFinish
+//   1. CallExprFinish
 // Else:
-//   1. Expression
-//   2. CallExpressionParameterFinish
-//   3. CallExpressionFinish
-CARBON_PARSE_STATE(CallExpression)
+//   1. Expr
+//   2. CallExprParameterFinish
+//   3. CallExprFinish
+CARBON_PARSE_STATE(CallExpr)
 
 // Handles the `,` or `)` after a call parameter.
 //
 // If `Comma`:
-//   1. Expression
-//   2. CallExpressionParameterFinish
+//   1. Expr
+//   2. CallExprParameterFinish
 // Else:
 //   (state done)
-CARBON_PARSE_STATE(CallExpressionParameterFinish)
+CARBON_PARSE_STATE(CallExprParameterFinish)
 
 // Handles finishing the call expression.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(CallExpressionFinish)
+CARBON_PARSE_STATE(CallExprFinish)
 
 // Handles processing at the `{` on a typical code block.
 //
@@ -251,128 +251,128 @@ CARBON_PARSE_STATE(DeclarationScopeLoop)
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS3(Period, Declaration, Expression, Struct)
+CARBON_PARSE_STATE_VARIANTS3(Period, Declaration, Expr, Struct)
 
-// Handles `->name` expressions. Identical to PeriodAsExpression except for the
+// Handles `->name` expressions. Identical to PeriodAsExpr except for the
 // leading token.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(ArrowExpression)
+CARBON_PARSE_STATE(ArrowExpr)
 
 // Handles processing of an expression.
 //
 // If `If`:
-//   1. Expression
-//   2. IfExpressionCondition
-//   3. IfExpressionFinish
+//   1. Expr
+//   2. IfExprCondition
+//   3. IfExprFinish
 // Else if valid prefix operator:
-//   1. Expression
-//   2. ExpressionLoopForPrefix
+//   1. Expr
+//   2. ExprLoopForPrefix
 // Else:
-//   1. ExpressionInPostfix
-//   2. ExpressionLoop
-CARBON_PARSE_STATE(Expression)
+//   1. ExprInPostfix
+//   2. ExprLoop
+CARBON_PARSE_STATE(Expr)
 
 // Handles the initial part of postfix expressions, such as an identifier or
 // literal value, then proceeds to the loop.
 //
 // If `Identifier` or literal (including type literals):
-//   1. ExpressionInPostfixLoop
+//   1. ExprInPostfixLoop
 // If `OpenCurlyBrace`:
-//   1. BraceExpression
-//   2. ExpressionInPostfixLoop
+//   1. BraceExpr
+//   2. ExprInPostfixLoop
 // If `OpenParen`:
-//   1. ParenExpression
-//   2. ExpressionInPostfixLoop
+//   1. ParenExpr
+//   2. ExprInPostfixLoop
 // If `OpenSquareBracket`:
-//   1. ArrayExpression
-//   2. ExpressionInPostfixLoop
+//   1. ArrayExpr
+//   2. ExprInPostfixLoop
 // Else:
 //   (state done)
-CARBON_PARSE_STATE(ExpressionInPostfix)
+CARBON_PARSE_STATE(ExprInPostfix)
 
 // Handles looping through elements following the initial postfix expression,
 // such as designators or parenthesized parameters.
 //
 // If `Period`:
-//   1. PeriodAsExpression
-//   2. ExpressionInPostfixLoop
+//   1. PeriodAsExpr
+//   2. ExprInPostfixLoop
 // If `MinusGreater`:
-//   1. ArrowExpression
-//   2. ExpressionInPostfixLoop
+//   1. ArrowExpr
+//   2. ExprInPostfixLoop
 // If `OpenParen`:
-//   1. CallExpression
-//   2. ExpressionInPostfixLoop
+//   1. CallExpr
+//   2. ExprInPostfixLoop
 // If `OpenSquareBracket`:
-//   1. IndexExpressionStart
-//   2. ExpressionInPostfixLoop
+//   1. IndexExprStart
+//   2. ExprInPostfixLoop
 // Else:
 //   (state done)
-CARBON_PARSE_STATE(ExpressionInPostfixLoop)
+CARBON_PARSE_STATE(ExprInPostfixLoop)
 
 // Handles processing of an expression.
 //
 // If binary operator:
-//   1. Expression
-//   2. ExpressionLoopForBinary
+//   1. Expr
+//   2. ExprLoopForBinary
 // If postfix operator:
-//   1. ExpressionLoop
+//   1. ExprLoop
 // Else:
 //   (state done)
-CARBON_PARSE_STATE(ExpressionLoop)
+CARBON_PARSE_STATE(ExprLoop)
 
-// Completes an ExpressionLoop pass by adding an infix operator, then goes back
-// to ExpressionLoop.
+// Completes an ExprLoop pass by adding an infix operator, then goes back
+// to ExprLoop.
 //
 // Always:
-//   1. ExpressionLoop
-CARBON_PARSE_STATE(ExpressionLoopForBinary)
+//   1. ExprLoop
+CARBON_PARSE_STATE(ExprLoopForBinary)
 
-// Completes an ExpressionLoop pass by adding a prefix operator, then goes back
-// to ExpressionLoop.
+// Completes an ExprLoop pass by adding a prefix operator, then goes back
+// to ExprLoop.
 //
 // Always:
-//   1. ExpressionLoop
-CARBON_PARSE_STATE(ExpressionLoopForPrefix)
+//   1. ExprLoop
+CARBON_PARSE_STATE(ExprLoopForPrefix)
 
 // Completes the condition of an `if` expression and handles the `then` token.
 //
 // If `Then`:
-//   1. Expression
-//   2. IfExpressionFinishThen
+//   1. Expr
+//   2. IfExprFinishThen
 // Else:
 //  (state done)
-CARBON_PARSE_STATE(IfExpressionFinishCondition)
+CARBON_PARSE_STATE(IfExprFinishCondition)
 
 // Completes the first alternative in an `if` expression and handles the `else`
 // token.
 //
 // If `Else`:
-//   1. Expression
-//   2. IfExpressionFinishElse
+//   1. Expr
+//   2. IfExprFinishElse
 // Else:
 //  (state done)
-CARBON_PARSE_STATE(IfExpressionFinishThen)
+CARBON_PARSE_STATE(IfExprFinishThen)
 
 // Completes the second alternative in an `if` expression.
 //
 // Always:
 //  (state done)
-CARBON_PARSE_STATE(IfExpressionFinishElse)
+CARBON_PARSE_STATE(IfExprFinishElse)
 
-// Completes an IfExpression.
+// Completes an IfExpr.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(IfExpressionFinish)
+CARBON_PARSE_STATE(IfExprFinish)
 
 // Handles the `;` for an expression statement, which is different from most
 // keyword statements.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE(ExpressionStatementFinish)
+CARBON_PARSE_STATE(ExprStatementFinish)
 
 // Handles a function's introducer.
 //
@@ -388,7 +388,7 @@ CARBON_PARSE_STATE(FunctionIntroducer)
 // handling.
 //
 // If `MinusGreater`:
-//   1. Expression
+//   1. Expr
 //   2. FunctionReturnTypeFinish
 //   3. FunctionSignatureFinish
 // Else:
@@ -480,7 +480,7 @@ CARBON_PARSE_STATE_VARIANTS2(ParameterListFinish, Implicit, Regular)
 // If `OpenCurlyBrace`:
 //   1. ParenConditionAs(If|While)Finish
 // Else:
-//   1. Expression
+//   1. Expr
 //   2. ParenConditionAs(If|While)Finish
 CARBON_PARSE_STATE_VARIANTS2(ParenCondition, If, While)
 
@@ -493,43 +493,44 @@ CARBON_PARSE_STATE_VARIANTS2(ParenConditionFinish, If, While)
 // Handles the `(` of a parenthesized expression.
 //
 // If `CloseParen`:
-//   1. ParenExpressionFinishAsTuple
+//   1. ParenExprFinishAsTuple
 // Else:
-//   1. Expression
-//   2. ParenExpressionParameterFinishAsUnknown
-//   3. ParenExpressionFinish
-CARBON_PARSE_STATE(ParenExpression)
+//   1. Expr
+//   2. ParenExprParameterFinishAsUnknown
+//   3. ParenExprFinish
+CARBON_PARSE_STATE(ParenExpr)
 
 // Handles the end of a parenthesized expression's parameter. This will start as
 // AsUnknown on the first parameter; if there are more, it switches to AsTuple
 // processing.
 //
 // If `Comma` without `CloseParen`:
-//   1. Expression
-//   2. ParenExpressionParameterFinishAsTuple
-//   SPECIAL: Parent becomes ParenExpressionFinishAsTuple
+//   1. Expr
+//   2. ParenExprParameterFinishAsTuple
+//   SPECIAL: Parent becomes ParenExprFinishAsTuple
 // If `Comma` with `CloseParen`:
 //   (state done)
-//   SPECIAL: Parent becomes ParenExpressionFinishAsTuple
+//   SPECIAL: Parent becomes ParenExprFinishAsTuple
 // Else `CloseParen`:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS2(ParenExpressionParameterFinish, Unknown, Tuple)
+CARBON_PARSE_STATE_VARIANTS2(ParenExprParameterFinish, Unknown, Tuple)
 
 // Handles the `)` of a parenthesized expression.
 //
 // Always:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS2(ParenExpressionFinish, Normal, Tuple)
+CARBON_PARSE_STATE_VARIANTS2(ParenExprFinish, Normal, Tuple)
 
 // Handles pattern parsing for a pattern, enqueuing type expression processing.
 // This covers parameter, `let`, and `var` support.
 //
 // If valid:
-//   1. Expression
+//   1. Expr
 //   2. PatternFinishAs(Generic|Regular)
 // Else:
 //   1. PatternFinish
-CARBON_PARSE_STATE_VARIANTS4(Pattern, ImplicitParameter, Parameter, Variable, Let)
+CARBON_PARSE_STATE_VARIANTS4(Pattern, ImplicitParameter, Parameter, Variable,
+                             Let)
 
 // Handles `addr` in a pattern.
 //
@@ -571,8 +572,8 @@ CARBON_PARSE_STATE_VARIANTS2(PatternFinish, Generic, Regular)
 // If `While`:
 //   1. StatementWhile
 // Else:
-//   1. Expression
-//   2. ExpressionStatementFinish
+//   1. Expr
+//   2. ExprStatementFinish
 CARBON_PARSE_STATE(Statement)
 
 // Handles `break` processing at the `;`.
@@ -603,7 +604,7 @@ CARBON_PARSE_STATE(StatementForHeader)
 // continuing.
 //
 // If `In` or `Colon`:
-//   1. Expression
+//   1. Expr
 //   2. StatementForHeaderFinish
 // Else:
 //   1. StatementForHeaderFinish
@@ -660,7 +661,7 @@ CARBON_PARSE_STATE(StatementIfElseBlockFinish)
 // If `Semi`:
 //   1. StatementReturnFinish
 // Else:
-//   1. Expression
+//   1. Expr
 //   2. StatementReturnFinish
 CARBON_PARSE_STATE(StatementReturn)
 
@@ -704,7 +705,7 @@ CARBON_PARSE_STATE(StatementWhileBlockFinish)
 // Always:
 //   (state done)
 CARBON_PARSE_STATE_VARIANTS3(TypeDefinitionFinish, Class, Interface,
-                              NamedConstraint)
+                             NamedConstraint)
 
 // Handles processing of a type's introducer.
 //
@@ -722,8 +723,7 @@ CARBON_PARSE_STATE_VARIANTS3(TypeIntroducer, Class, Interface, NamedConstraint)
 //   2. TypeDefinitionFinishAs(Class|Interface|NamedConstraint)
 // Else:
 //   (state done)
-CARBON_PARSE_STATE_VARIANTS3(TypeAfterParams, Class, Interface,
-                              NamedConstraint)
+CARBON_PARSE_STATE_VARIANTS3(TypeAfterParams, Class, Interface, NamedConstraint)
 
 // Handles the start of a `var`.
 //
@@ -737,7 +737,7 @@ CARBON_PARSE_STATE_VARIANTS2(Var, Semicolon, For)
 // semicolon.
 //
 // If `Equal`:
-//   1. Expression
+//   1. Expr
 // Else:
 //   (state done)
 CARBON_PARSE_STATE(VarAfterPattern)
@@ -759,7 +759,7 @@ CARBON_PARSE_STATE(Let)
 // Handles `let` after the pattern, followed by an initializer.
 //
 // If `Equal`:
-//   1. Expression
+//   1. Expr
 // Else:
 //   (state done)
 CARBON_PARSE_STATE(LetAfterPattern)

toolchain/parse/testdata/array/fail_require_close_bracket.carbon

@@ -24,11 +24,11 @@ var x: [i32;;
 // CHECK:STDOUT:     {kind: 'FileStart', text: ''},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:             {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'ArrayExpressionSemi', text: ';', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'ArrayExprSemi', text: ';', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'ArrayExpression', text: ']', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'ArrayExpr', text: ']', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: 'var', has_error: yes, subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/array/fail_require_semi.carbon

@@ -14,10 +14,10 @@ var x: [i32];
 // CHECK:STDOUT:     {kind: 'FileStart', text: ''},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:             {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'ArrayExpressionSemi', text: ']', has_error: yes, subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'ArrayExpression', text: ']', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ArrayExprSemi', text: ']', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'ArrayExpr', text: ']', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/array/with_length.carbon

@@ -11,11 +11,11 @@ var x: [i32; 10];
 // CHECK:STDOUT:     {kind: 'FileStart', text: ''},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:             {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'ArrayExpressionSemi', text: ';', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'ArrayExprSemi', text: ';', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'Literal', text: '10'},
-// CHECK:STDOUT:         {kind: 'ArrayExpression', text: ']', subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'ArrayExpr', text: ']', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/array/without_length.carbon

@@ -11,10 +11,10 @@ var x: [i32;];
 // CHECK:STDOUT:     {kind: 'FileStart', text: ''},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:             {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'ArrayExpressionSemi', text: ';', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'ArrayExpression', text: ']', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ArrayExprSemi', text: ';', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'ArrayExpr', text: ']', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/basics/fail_invalid_designators.carbon

@@ -28,18 +28,18 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'Name', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', has_error: yes, subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:         {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'Name', text: 'fn', has_error: yes},
-// CHECK:STDOUT:         {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:         {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'Name', text: '42', has_error: yes},
-// CHECK:STDOUT:         {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/basics/fail_paren_match_regression.carbon

@@ -23,9 +23,9 @@ var = (foo {})
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: '=', has_error: yes},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: '=', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:         {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'foo'},
-// CHECK:STDOUT:       {kind: 'ParenExpression', text: ')', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'foo'},
+// CHECK:STDOUT:       {kind: 'ParenExpr', text: ')', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: 'var', has_error: yes, subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/basics/function_call.carbon

@@ -17,25 +17,25 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:                       {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:                       {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:                       {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:                     {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
+// CHECK:STDOUT:                     {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
 // CHECK:STDOUT:                     {kind: 'Name', text: 'f'},
-// CHECK:STDOUT:                   {kind: 'MemberAccessExpression', text: '.', subtree_size: 5},
-// CHECK:STDOUT:                 {kind: 'CallExpressionStart', text: '(', subtree_size: 6},
-// CHECK:STDOUT:                   {kind: 'NameExpression', text: 'c'},
+// CHECK:STDOUT:                   {kind: 'MemberAccessExpr', text: '.', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'CallExprStart', text: '(', subtree_size: 6},
+// CHECK:STDOUT:                   {kind: 'NameExpr', text: 'c'},
 // CHECK:STDOUT:                   {kind: 'Name', text: 'd'},
-// CHECK:STDOUT:                 {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
-// CHECK:STDOUT:                 {kind: 'CallExpressionComma', text: ','},
-// CHECK:STDOUT:                   {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:                   {kind: 'NameExpression', text: 'e'},
-// CHECK:STDOUT:                 {kind: 'ParenExpression', text: ')', subtree_size: 3},
-// CHECK:STDOUT:               {kind: 'CallExpression', text: ')', subtree_size: 14},
+// CHECK:STDOUT:                 {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
+// CHECK:STDOUT:                 {kind: 'CallExprComma', text: ','},
+// CHECK:STDOUT:                   {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:                   {kind: 'NameExpr', text: 'e'},
+// CHECK:STDOUT:                 {kind: 'ParenExpr', text: ')', subtree_size: 3},
+// CHECK:STDOUT:               {kind: 'CallExpr', text: ')', subtree_size: 14},
 // CHECK:STDOUT:               {kind: 'Name', text: 'g'},
-// CHECK:STDOUT:             {kind: 'MemberAccessExpression', text: '.', subtree_size: 16},
-// CHECK:STDOUT:           {kind: 'CallExpressionStart', text: '(', subtree_size: 17},
-// CHECK:STDOUT:         {kind: 'CallExpression', text: ')', subtree_size: 18},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 19},
+// CHECK:STDOUT:             {kind: 'MemberAccessExpr', text: '.', subtree_size: 16},
+// CHECK:STDOUT:           {kind: 'CallExprStart', text: '(', subtree_size: 17},
+// CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 18},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 19},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 25},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/basics/numeric_literals.carbon

@@ -35,14 +35,14 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'Name', text: 'ints'},
-// CHECK:STDOUT:               {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:               {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionSemi', text: ';', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'ArrayExprSemi', text: ';', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'Literal', text: '5'},
-// CHECK:STDOUT:           {kind: 'ArrayExpression', text: ']', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'ArrayExpr', text: ']', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:           {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:           {kind: 'ParenExprOrTupleLiteralStart', text: '('},
 // CHECK:STDOUT:           {kind: 'Literal', text: '8'},
 // CHECK:STDOUT:           {kind: 'TupleLiteralComma', text: ','},
 // CHECK:STDOUT:           {kind: 'Literal', text: '9'},
@@ -57,14 +57,14 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 22},
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'Name', text: 'floats'},
-// CHECK:STDOUT:               {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:               {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'f64'},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionSemi', text: ';', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'ArrayExprSemi', text: ';', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'Literal', text: '7'},
-// CHECK:STDOUT:           {kind: 'ArrayExpression', text: ']', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'ArrayExpr', text: ']', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:           {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:           {kind: 'ParenExprOrTupleLiteralStart', text: '('},
 // CHECK:STDOUT:           {kind: 'Literal', text: '0.9'},
 // CHECK:STDOUT:           {kind: 'TupleLiteralComma', text: ','},
 // CHECK:STDOUT:           {kind: 'Literal', text: '8.0'},

toolchain/parse/testdata/basics/parens.carbon

@@ -22,15 +22,15 @@ fn F(n: i32) -> i32 {
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 10},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
-// CHECK:STDOUT:           {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:             {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:               {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:                 {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'n'},
-// CHECK:STDOUT:               {kind: 'ParenExpression', text: ')', subtree_size: 3},
-// CHECK:STDOUT:             {kind: 'ParenExpression', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'ParenExpression', text: ')', subtree_size: 7},
-// CHECK:STDOUT:         {kind: 'ParenExpression', text: ')', subtree_size: 9},
+// CHECK:STDOUT:           {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:             {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:               {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:                 {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'n'},
+// CHECK:STDOUT:               {kind: 'ParenExpr', text: ')', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'ParenExpr', text: ')', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'ParenExpr', text: ')', subtree_size: 7},
+// CHECK:STDOUT:         {kind: 'ParenExpr', text: ')', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/class/fn_definitions.carbon

@@ -22,7 +22,7 @@ class Foo {
 // CHECK:STDOUT:           {kind: 'Name', text: 'Make'},
 // CHECK:STDOUT:             {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:           {kind: 'ParameterList', text: ')', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'ReturnStatementStart', text: 'return'},
@@ -38,7 +38,7 @@ class Foo {
 // CHECK:STDOUT:           {kind: 'Name', text: 'Baz'},
 // CHECK:STDOUT:             {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:               {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:               {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:               {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterList', text: ']', subtree_size: 5},
 // CHECK:STDOUT:             {kind: 'ParameterListStart', text: '('},
@@ -47,16 +47,16 @@ class Foo {
 // CHECK:STDOUT:           {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 12},
 // CHECK:STDOUT:           {kind: 'ReturnStatementStart', text: 'return'},
-// CHECK:STDOUT:             {kind: 'SelfValueNameExpression', text: 'self'},
+// CHECK:STDOUT:             {kind: 'SelfValueNameExpr', text: 'self'},
 // CHECK:STDOUT:             {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:           {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ReturnStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:           {kind: 'FunctionIntroducer', text: 'fn'},
 // CHECK:STDOUT:           {kind: 'Name', text: 'Modify'},
 // CHECK:STDOUT:             {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:                 {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:                   {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:                   {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:                 {kind: 'PostfixOperator', text: '*', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'PatternBinding', text: ':', subtree_size: 4},
 // CHECK:STDOUT:             {kind: 'Address', text: 'addr', subtree_size: 5},
@@ -64,12 +64,12 @@ class Foo {
 // CHECK:STDOUT:             {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:           {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 12},
-// CHECK:STDOUT:               {kind: 'SelfValueNameExpression', text: 'self'},
+// CHECK:STDOUT:               {kind: 'SelfValueNameExpr', text: 'self'},
 // CHECK:STDOUT:               {kind: 'Name', text: 'x'},
-// CHECK:STDOUT:             {kind: 'PointerMemberAccessExpression', text: '->', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PointerMemberAccessExpr', text: '->', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'Literal', text: '1'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: '=', subtree_size: 5},
-// CHECK:STDOUT:         {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'FunctionDefinition', text: '}', subtree_size: 19},
 // CHECK:STDOUT:     {kind: 'ClassDefinition', text: '}', subtree_size: 57},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/for/fail_colon_instead_of_in.carbon

@@ -27,14 +27,14 @@ fn foo() {
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ForIn', text: ':', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'y'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'y'},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: ')', subtree_size: 8},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'Print'},
-// CHECK:STDOUT:               {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'x'},
-// CHECK:STDOUT:             {kind: 'CallExpression', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'Print'},
+// CHECK:STDOUT:               {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'x'},
+// CHECK:STDOUT:             {kind: 'CallExpr', text: ')', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ForStatement', text: 'for', subtree_size: 16},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},

toolchain/parse/testdata/for/fail_missing_in.carbon

@@ -27,14 +27,14 @@ fn foo() {
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ForIn', text: 'var', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'y'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'y'},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: ')', subtree_size: 8},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'Print'},
-// CHECK:STDOUT:               {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'x'},
-// CHECK:STDOUT:             {kind: 'CallExpression', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'Print'},
+// CHECK:STDOUT:               {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'x'},
+// CHECK:STDOUT:             {kind: 'CallExpr', text: ')', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ForStatement', text: 'for', subtree_size: 16},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},

toolchain/parse/testdata/for/fail_missing_var.carbon

@@ -22,14 +22,14 @@ fn foo() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ForHeaderStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'y'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'y'},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: ')', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'Print'},
-// CHECK:STDOUT:               {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'x'},
-// CHECK:STDOUT:             {kind: 'CallExpression', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'Print'},
+// CHECK:STDOUT:               {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'x'},
+// CHECK:STDOUT:             {kind: 'CallExpr', text: ')', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ForStatement', text: 'for', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 17},

toolchain/parse/testdata/for/fail_square_brackets.carbon

@@ -30,10 +30,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ForHeaderStart', text: 'for', has_error: yes},
-// CHECK:STDOUT:               {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:               {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:               {kind: 'InvalidParse', text: ']', has_error: yes},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionSemi', text: ']', has_error: yes, subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'ArrayExpression', text: ']', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:             {kind: 'ArrayExprSemi', text: ']', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'ArrayExpr', text: ']', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: 'for', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 2},

toolchain/parse/testdata/for/nested.carbon

@@ -26,7 +26,7 @@ fn foo() {
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ForIn', text: 'in', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'x'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'x'},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: ')', subtree_size: 8},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:               {kind: 'ForHeaderStart', text: '('},
@@ -35,14 +35,14 @@ fn foo() {
 // CHECK:STDOUT:                   {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:                 {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'ForIn', text: 'in', subtree_size: 5},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'y'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'y'},
 // CHECK:STDOUT:             {kind: 'ForHeader', text: ')', subtree_size: 8},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                     {kind: 'NameExpression', text: 'Print'},
-// CHECK:STDOUT:                   {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:                   {kind: 'NameExpression', text: 'z'},
-// CHECK:STDOUT:                 {kind: 'CallExpression', text: ')', subtree_size: 4},
-// CHECK:STDOUT:               {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:                     {kind: 'NameExpr', text: 'Print'},
+// CHECK:STDOUT:                   {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:                   {kind: 'NameExpr', text: 'z'},
+// CHECK:STDOUT:                 {kind: 'CallExpr', text: ')', subtree_size: 4},
+// CHECK:STDOUT:               {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: '}', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'ForStatement', text: 'for', subtree_size: 16},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 18},

toolchain/parse/testdata/for/simple.carbon

@@ -24,14 +24,14 @@ fn foo() {
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ForIn', text: 'in', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'y'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'y'},
 // CHECK:STDOUT:         {kind: 'ForHeader', text: ')', subtree_size: 8},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'Print'},
-// CHECK:STDOUT:               {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'x'},
-// CHECK:STDOUT:             {kind: 'CallExpression', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'Print'},
+// CHECK:STDOUT:               {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'x'},
+// CHECK:STDOUT:             {kind: 'CallExpr', text: ')', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ForStatement', text: 'for', subtree_size: 16},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},

toolchain/parse/testdata/function/definition/fail_identifier_in_statements.carbon

@@ -21,7 +21,7 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'NameExpression', text: 'bar'},
+// CHECK:STDOUT:       {kind: 'NameExpr', text: 'bar'},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', has_error: yes, subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/function/definition/with_params.carbon

@@ -23,15 +23,15 @@ fn foo(bar: i64, baz: i64) {
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 12},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'foo'},
-// CHECK:STDOUT:           {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'baz'},
-// CHECK:STDOUT:           {kind: 'CallExpressionComma', text: ','},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'bar'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'baz'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'foo'},
+// CHECK:STDOUT:           {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'baz'},
+// CHECK:STDOUT:           {kind: 'CallExprComma', text: ','},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'bar'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'baz'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: '+', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'CallExpression', text: ')', subtree_size: 8},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 9},
+// CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 8},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/generics/interface/basic.carbon

@@ -19,30 +19,30 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'Name', text: 'Add'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:             {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 15},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'Add'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:             {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'foo'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'foo'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 15},
 // CHECK:STDOUT:     {kind: 'InterfaceDefinition', text: '}', subtree_size: 34},

toolchain/parse/testdata/generics/interface/fail_no_impl_allowed.carbon

@@ -23,15 +23,15 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'Name', text: 'Add'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:             {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: 'fn', has_error: yes, subtree_size: 15},
 // CHECK:STDOUT:     {kind: 'InterfaceDefinition', text: '}', subtree_size: 19},

toolchain/parse/testdata/generics/interface/fail_self_param_syntax.carbon

@@ -31,10 +31,10 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 15},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
@@ -46,10 +46,10 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 15},
 // CHECK:STDOUT:     {kind: 'InterfaceDefinition', text: '}', subtree_size: 34},

toolchain/parse/testdata/generics/interface/non_instance_fn.carbon

@@ -18,7 +18,7 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'Name', text: 'FooFactory'},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'InterfaceDefinition', text: '}', subtree_size: 11},

toolchain/parse/testdata/generics/interface/self_pointer.carbon

@@ -19,34 +19,34 @@ interface Foo {
 // CHECK:STDOUT:         {kind: 'Name', text: 'Sub'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:               {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:                 {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:                 {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 17},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'Sub'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:               {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'foo'},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'foo'},
 // CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'PatternBinding', text: ':', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: ';', subtree_size: 17},
 // CHECK:STDOUT:     {kind: 'InterfaceDefinition', text: '}', subtree_size: 38},

toolchain/parse/testdata/generics/named_constraint/fail_no_impl_allowed.carbon

@@ -21,15 +21,15 @@ constraint Foo {
 // CHECK:STDOUT:         {kind: 'Name', text: 'Add'},
 // CHECK:STDOUT:           {kind: 'ImplicitParameterListStart', text: '['},
 // CHECK:STDOUT:             {kind: 'SelfValueName', text: 'self'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ImplicitParameterList', text: ']', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:             {kind: 'Name', text: 'b'},
-// CHECK:STDOUT:             {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:             {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:           {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'SelfTypeNameExpression', text: 'Self'},
+// CHECK:STDOUT:           {kind: 'SelfTypeNameExpr', text: 'Self'},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDeclaration', text: 'fn', has_error: yes, subtree_size: 15},
 // CHECK:STDOUT:     {kind: 'NamedConstraintDefinition', text: '}', subtree_size: 19},

toolchain/parse/testdata/if/basic.carbon

@@ -23,19 +23,19 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:               {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:                   {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:                   {kind: 'NameExpression', text: 'c'},
+// CHECK:STDOUT:                   {kind: 'NameExpr', text: 'c'},
 // CHECK:STDOUT:                 {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:                   {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                     {kind: 'NameExpression', text: 'd'},
-// CHECK:STDOUT:                   {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                     {kind: 'NameExpr', text: 'd'},
+// CHECK:STDOUT:                   {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:                 {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:               {kind: 'IfStatement', text: 'if', subtree_size: 8},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: '}', subtree_size: 10},

toolchain/parse/testdata/if/else.carbon

@@ -28,48 +28,48 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:               {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'c'},
-// CHECK:STDOUT:               {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'c'},
+// CHECK:STDOUT:               {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:             {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'd'},
-// CHECK:STDOUT:               {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'd'},
+// CHECK:STDOUT:               {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IfStatement', text: 'if', subtree_size: 13},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 15},
 // CHECK:STDOUT:         {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'e'},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'e'},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 24},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'x'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'x'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'f'},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'f'},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:             {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'x'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'x'},
 // CHECK:STDOUT:           {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'g'},
-// CHECK:STDOUT:             {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'g'},
+// CHECK:STDOUT:             {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:             {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'h'},
-// CHECK:STDOUT:             {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'h'},
+// CHECK:STDOUT:             {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'IfStatement', text: 'if', subtree_size: 13},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 22},

toolchain/parse/testdata/if/fail_else_unbraced.carbon

@@ -38,48 +38,48 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: 'if', has_error: yes},
 // CHECK:STDOUT:               {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: 'c', has_error: yes},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'c'},
-// CHECK:STDOUT:               {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'c'},
+// CHECK:STDOUT:               {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: 'c', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:             {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: 'd', has_error: yes},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'd'},
-// CHECK:STDOUT:               {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'd'},
+// CHECK:STDOUT:               {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: 'd', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IfStatement', text: 'if', subtree_size: 13},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: 'if', has_error: yes, subtree_size: 15},
 // CHECK:STDOUT:         {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: 'e', has_error: yes},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'e'},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'e'},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: 'e', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 24},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'x'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'x'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'f'},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'f'},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:             {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'x'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'x'},
 // CHECK:STDOUT:           {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'g'},
-// CHECK:STDOUT:             {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'g'},
+// CHECK:STDOUT:             {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IfStatementElse', text: 'else'},
 // CHECK:STDOUT:             {kind: 'CodeBlockStart', text: '{'},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'h'},
-// CHECK:STDOUT:             {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'h'},
+// CHECK:STDOUT:             {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CodeBlock', text: '}', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'IfStatement', text: 'if', subtree_size: 13},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 22},

toolchain/parse/testdata/if/fail_errors.carbon

@@ -35,7 +35,7 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: 'if', has_error: yes},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: 'if', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 2},
@@ -47,13 +47,13 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'd'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'd'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '}', has_error: yes},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: '}', has_error: yes},

toolchain/parse/testdata/if/fail_square_brackets.carbon

@@ -26,10 +26,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: 'if', has_error: yes},
-// CHECK:STDOUT:               {kind: 'ArrayExpressionStart', text: '['},
+// CHECK:STDOUT:               {kind: 'ArrayExprStart', text: '['},
 // CHECK:STDOUT:               {kind: 'InvalidParse', text: ']', has_error: yes},
-// CHECK:STDOUT:             {kind: 'ArrayExpressionSemi', text: ']', has_error: yes, subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'ArrayExpression', text: ']', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:             {kind: 'ArrayExprSemi', text: ']', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'ArrayExpr', text: ']', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: 'if', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: '}', subtree_size: 2},

toolchain/parse/testdata/if/fail_unbraced.carbon

@@ -30,19 +30,19 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: 'if', has_error: yes},
 // CHECK:STDOUT:               {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'CodeBlockStart', text: 'if', has_error: yes},
 // CHECK:STDOUT:                   {kind: 'IfConditionStart', text: '('},
-// CHECK:STDOUT:                   {kind: 'NameExpression', text: 'c'},
+// CHECK:STDOUT:                   {kind: 'NameExpr', text: 'c'},
 // CHECK:STDOUT:                 {kind: 'IfCondition', text: ')', subtree_size: 3},
 // CHECK:STDOUT:                   {kind: 'CodeBlockStart', text: 'd', has_error: yes},
-// CHECK:STDOUT:                     {kind: 'NameExpression', text: 'd'},
-// CHECK:STDOUT:                   {kind: 'ExpressionStatement', text: ';', subtree_size: 2},
+// CHECK:STDOUT:                     {kind: 'NameExpr', text: 'd'},
+// CHECK:STDOUT:                   {kind: 'ExprStatement', text: ';', subtree_size: 2},
 // CHECK:STDOUT:                 {kind: 'CodeBlock', text: 'd', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:               {kind: 'IfStatement', text: 'if', subtree_size: 8},
 // CHECK:STDOUT:             {kind: 'CodeBlock', text: 'if', has_error: yes, subtree_size: 10},

toolchain/parse/testdata/if_expression/basic.carbon

@@ -30,12 +30,12 @@ fn F(b: bool, x: i32, y: i32) -> bool {
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 18},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'b'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'x'},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'y'},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'else', subtree_size: 6},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'b'},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'x'},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'y'},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'else', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 27},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_condition_missing.carbon

@@ -25,10 +25,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:             {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', has_error: yes, subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', has_error: yes, subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'if', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'if', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 17},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_else_expr_missing.carbon

@@ -25,11 +25,11 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'Literal', text: '1'},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'else', has_error: yes, subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'else', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 12},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_else_missing.carbon

@@ -25,11 +25,11 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'Literal', text: '1'},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'if', has_error: yes, subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'if', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 12},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_then_expr_missing.carbon

@@ -25,11 +25,11 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', has_error: yes, subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', has_error: yes, subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'if', has_error: yes, subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'if', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 12},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_then_missing.carbon

@@ -25,10 +25,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
 // CHECK:STDOUT:           {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'if', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'if', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 17},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/fail_top_level_if.carbon

@@ -30,7 +30,7 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'IfCondition', text: 'if', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: 'then', has_error: yes},
 // CHECK:STDOUT:             {kind: 'InvalidParse', text: 'then', has_error: yes},
-// CHECK:STDOUT:           {kind: 'ExpressionStatement', text: ';', has_error: yes, subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'ExprStatement', text: ';', has_error: yes, subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CodeBlock', text: 'then', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'IfStatement', text: 'if', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 14},

toolchain/parse/testdata/if_expression/in_type.carbon

@@ -23,22 +23,22 @@ fn F() -> if true then i32 else i32* {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:             {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'IfExpressionElse', text: 'else', subtree_size: 7},
+// CHECK:STDOUT:           {kind: 'IfExprElse', text: 'else', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 8},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 13},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
 // CHECK:STDOUT:             {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'n'},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'n'},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'n'},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'n'},
 // CHECK:STDOUT:           {kind: 'PrefixOperator', text: '&', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'else', subtree_size: 7},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'else', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 23},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/if_expression/precedence.carbon

@@ -22,21 +22,21 @@ fn F(b: bool) -> bool {
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 10},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperand', text: 'and', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'InfixOperator', text: 'and', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'IfExpressionIf', text: 'if', subtree_size: 5},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:           {kind: 'IfExprIf', text: 'if', subtree_size: 5},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperand', text: 'and', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'InfixOperator', text: 'and', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'IfExpressionThen', text: 'then', subtree_size: 5},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 5},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'ShortCircuitOperand', text: 'or', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: 'or', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'IfExpressionElse', text: 'else', subtree_size: 15},
+// CHECK:STDOUT:         {kind: 'IfExprElse', text: 'else', subtree_size: 15},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 17},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 28},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/index/assign_to_var.carbon

@@ -14,10 +14,10 @@ var v: i32 = t[0];
 // CHECK:STDOUT:         {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 't'},
-// CHECK:STDOUT:         {kind: 'IndexExpressionStart', text: '[', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 't'},
+// CHECK:STDOUT:         {kind: 'IndexExprStart', text: '[', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'Literal', text: '0'},
-// CHECK:STDOUT:       {kind: 'IndexExpression', text: ']', subtree_size: 4},
+// CHECK:STDOUT:       {kind: 'IndexExpr', text: ']', subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/index/fail_empty_expr.carbon

@@ -17,10 +17,10 @@ var v: i32 = t[];
 // CHECK:STDOUT:         {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 't'},
-// CHECK:STDOUT:         {kind: 'IndexExpressionStart', text: '[', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 't'},
+// CHECK:STDOUT:         {kind: 'IndexExprStart', text: '[', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: ']', has_error: yes},
-// CHECK:STDOUT:       {kind: 'IndexExpression', text: ']', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:       {kind: 'IndexExpr', text: ']', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/index/fail_malformed_expr.carbon

@@ -17,10 +17,10 @@ var v: i32 = t[0,];
 // CHECK:STDOUT:         {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 't'},
-// CHECK:STDOUT:         {kind: 'IndexExpressionStart', text: '[', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 't'},
+// CHECK:STDOUT:         {kind: 'IndexExprStart', text: '[', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'Literal', text: '0'},
-// CHECK:STDOUT:       {kind: 'IndexExpression', text: ']', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:       {kind: 'IndexExpr', text: ']', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/namespace/basic.carbon

@@ -21,12 +21,12 @@ fn Bar() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'Foo'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'Foo'},
 // CHECK:STDOUT:               {kind: 'Name', text: 'Baz'},
-// CHECK:STDOUT:             {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'CallExpressionStart', text: '(', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'CallExpression', text: ')', subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:             {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'CallExprStart', text: '(', subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 5},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 12},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/namespace/fail_arrow.carbon

@@ -19,9 +19,9 @@ fn Foo->Bar() {}
 // CHECK:STDOUT:     {kind: 'Namespace', text: ';', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
 // CHECK:STDOUT:         {kind: 'Name', text: 'Foo'},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'Bar'},
-// CHECK:STDOUT:             {kind: 'CallExpressionStart', text: '(', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'CallExpression', text: ')', subtree_size: 3},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'Bar'},
+// CHECK:STDOUT:             {kind: 'CallExprStart', text: '(', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'CallExpr', text: ')', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', has_error: yes, subtree_size: 7},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 8},

toolchain/parse/testdata/namespace/nested.carbon

@@ -31,14 +31,14 @@ fn Foo.Bar.Baz() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 9},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'Foo'},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'Foo'},
 // CHECK:STDOUT:                 {kind: 'Name', text: 'Bar'},
-// CHECK:STDOUT:               {kind: 'MemberAccessExpression', text: '.', subtree_size: 3},
+// CHECK:STDOUT:               {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'Name', text: 'Wiz'},
-// CHECK:STDOUT:             {kind: 'MemberAccessExpression', text: '.', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'CallExpressionStart', text: '(', subtree_size: 6},
-// CHECK:STDOUT:         {kind: 'CallExpression', text: ')', subtree_size: 7},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 8},
+// CHECK:STDOUT:             {kind: 'MemberAccessExpr', text: '.', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'CallExprStart', text: '(', subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 7},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 18},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/assign.carbon

@@ -44,56 +44,56 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'Literal', text: '1'},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 7},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '*=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '/=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '+=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '-=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '%=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '&=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '|=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '^=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '<<=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '>>=', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'PrefixOperator', text: '++', subtree_size: 2},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:         {kind: 'PrefixOperator', text: '--', subtree_size: 2},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 70},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/associative.carbon

@@ -16,14 +16,14 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperand', text: 'and', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'InfixOperator', text: 'and', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'ShortCircuitOperand', text: 'and', subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'c'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'c'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: 'and', subtree_size: 7},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 8},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 14},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/fail_chained_assign.carbon

@@ -33,12 +33,12 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 5},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: '=', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'Literal', text: '1'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/fail_infix_uneven_space_after.carbon

@@ -19,7 +19,7 @@ var n: i8 = n* n;
 // CHECK:STDOUT:         {kind: 'Literal', text: 'i8'},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'n'},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'n'},
 // CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', has_error: yes, subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},

toolchain/parse/testdata/operators/fail_invalid_infix.carbon

@@ -28,7 +28,7 @@ var c: i32 = == ;
 // CHECK:STDOUT:         {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'n'},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: ';', has_error: yes},
 // CHECK:STDOUT:       {kind: 'InfixOperator', text: '==', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 9},
@@ -38,7 +38,7 @@ var c: i32 = == ;
 // CHECK:STDOUT:       {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: '==', has_error: yes},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'n'},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'n'},
 // CHECK:STDOUT:       {kind: 'InfixOperator', text: '==', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDeclaration', text: ';', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},

toolchain/parse/testdata/operators/fail_postincrement.carbon

@@ -32,10 +32,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'Literal', text: '0'},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 7},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'n'},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', has_error: yes, subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'NameExpression', text: 'n'},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', has_error: yes, subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'n'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', has_error: yes, subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'NameExpr', text: 'n'},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', has_error: yes, subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 17},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/fail_precedence_and_or.carbon

@@ -19,14 +19,14 @@ fn F() {
 // CHECK:STDOUT:           {kind: 'ParameterListStart', text: '('},
 // CHECK:STDOUT:         {kind: 'ParameterList', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
-// CHECK:STDOUT:                 {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:                 {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperand', text: 'and', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'b'},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'b'},
 // CHECK:STDOUT:             {kind: 'InfixOperator', text: 'and', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'ShortCircuitOperand', text: 'or', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'c'},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'c'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: 'or', has_error: yes, subtree_size: 7},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 8},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 14},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/fail_precedence_as.carbon

@@ -37,19 +37,19 @@ fn F(n: i32) {
 // CHECK:STDOUT:           {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'Literal', text: 'bool'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 4},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:             {kind: 'Literal', text: '1'},
 // CHECK:STDOUT:             {kind: 'Literal', text: '1'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: '+', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:             {kind: 'Literal', text: '5'},
 // CHECK:STDOUT:             {kind: 'Literal', text: '2'},
 // CHECK:STDOUT:           {kind: 'InfixOperator', text: '%', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'Literal', text: 'i32'},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 26},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]

toolchain/parse/testdata/operators/fail_precedence_assign.carbon

@@ -43,33 +43,33 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'PatternBinding', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableDeclaration', text: ';', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'Literal', text: '1'},
-// CHECK:STDOUT:             {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:           {kind: 'ParenExpression', text: ')', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'ParenExprOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:           {kind: 'ParenExpr', text: ')', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', subtree_size: 5},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 6},
-// CHECK:STDOUT:           {kind: 'ParenExpressionOrTupleLiteralStart', text: '('},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
+// CHECK:STDOUT:           {kind: 'ParenExprOrTupleLiteralStart', text: '('},
 // CHECK:STDOUT:               {kind: 'Literal', text: 'true'},
-// CHECK:STDOUT:             {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:             {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'IfExprIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'InvalidParse', text: '+=', has_error: yes},
-// CHECK:STDOUT:           {kind: 'IfExpressionElse', text: 'if', has_error: yes, subtree_size: 6},
-// CHECK:STDOUT:         {kind: 'ParenExpression', text: ')', has_error: yes, subtree_size: 8},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 9},
-// CHECK:STDOUT:           {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'a'},
+// CHECK:STDOUT:           {kind: 'IfExprElse', text: 'if', has_error: yes, subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'ParenExpr', text: ')', has_error: yes, subtree_size: 8},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 9},
+// CHECK:STDOUT:           {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'PrefixOperator', text: '++', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', subtree_size: 4},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 5},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'c'},
-// CHECK:STDOUT:             {kind: 'IfExpressionIf', text: 'if', subtree_size: 2},
-// CHECK:STDOUT:               {kind: 'NameExpression', text: 'a'},
-// CHECK:STDOUT:             {kind: 'IfExpressionThen', text: 'then', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'NameExpression', text: 'b'},
-// CHECK:STDOUT:           {kind: 'IfExpressionElse', text: 'else', subtree_size: 6},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 5},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'c'},
+// CHECK:STDOUT:             {kind: 'IfExprIf', text: 'if', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'NameExpr', text: 'a'},
+// CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'NameExpr', text: 'b'},
+// CHECK:STDOUT:           {kind: 'IfExprElse', text: 'else', subtree_size: 6},
 // CHECK:STDOUT:         {kind: 'PrefixOperator', text: '++', subtree_size: 7},
-// CHECK:STDOUT:       {kind: 'ExpressionStatement', text: ';', subtree_size: 8},
+// CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 39},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]