From 7c7afc9e320f22f59f0080b84ead2f0611b94447 Mon Sep 17 00:00:00 2001
From: Jon Ross-Perkins <jperkins@google.com>
Date: Wed, 13 Dec 2023 11:52:20 -0800
Subject: [PATCH] Split out infix and prefix operators to separate node kinds.
 (#3481)

This leaves a single state for each in the expr loop. I was trying to
think through ways to have per-token states, but they felt sort of
bulky.

Note this is more verbose: but I think the long-term is going to be that
when we start wanting to add handlers, we're going to need to switch to
different names based on the token found. As a consequence, the parse
state logic will end up diverging a little, and we'll just want to align
towards boilerplate handlers.

Short-term, this opens up a path for saying that each parse node
corresponds to precisely one token in success states, and separates out
what were becoming big handler functions in check.
---
 toolchain/check/handle_operator.cpp           | 424 ++++++++++++------
 toolchain/check/node_stack.h                  |  10 +-
 .../index/fail_negative_indexing.carbon       |   2 +-
 .../operators/fail_type_mismatch_once.carbon  |   2 +-
 .../operators/fail_unimplemented_op.carbon    |   2 +-
 toolchain/parse/handle_expr.cpp               |  57 ++-
 toolchain/parse/node_kind.def                 | 123 +++--
 toolchain/parse/state.def                     |   4 +-
 .../testdata/class/fn_definitions.carbon      |   4 +-
 .../testdata/function/declaration/addr.carbon |   2 +-
 .../function/definition/with_params.carbon    |   2 +-
 .../generics/interface/default_fn.carbon      |   2 +-
 .../generics/interface/self_pointer.carbon    |   4 +-
 .../parse/testdata/if_expr/in_type.carbon     |   4 +-
 .../parse/testdata/operators/assign.carbon    |  26 +-
 .../operators/fail_chained_assign.carbon      |   4 +-
 .../fail_infix_uneven_space_after.carbon      |   2 +-
 .../operators/fail_invalid_infix.carbon       |   6 +-
 .../operators/fail_precedence_as.carbon       |  12 +-
 .../operators/fail_precedence_assign.carbon   |   8 +-
 .../fail_precedence_star_minus.carbon         |   4 +-
 .../fail_precedence_star_star.carbon          |   4 +-
 .../operators/fail_star_star_no_space.carbon  |   4 +-
 .../testdata/operators/fail_variety.carbon    |  20 +-
 .../testdata/operators/fixity_in_call.carbon  |   4 +-
 .../operators/fixity_in_params.carbon         |   2 +-
 .../testdata/operators/fixity_in_var.carbon   |   4 +-
 .../operators/fixity_with_assign.carbon       |  20 +-
 .../parse/testdata/operators/infix.carbon     |   2 +-
 .../testdata/operators/infix_no_space.carbon  |   2 +-
 .../operators/infix_with_paren_after.carbon   |   2 +-
 .../operators/infix_with_paren_before.carbon  |   2 +-
 .../parse/testdata/operators/postfix.carbon   |   2 +-
 .../testdata/operators/postfix_repeat.carbon  |   8 +-
 .../operators/postfix_space_after_op.carbon   |   2 +-
 .../testdata/operators/precedence_as.carbon   |  22 +-
 .../operators/precedence_assign.carbon        |   8 +-
 .../testdata/operators/precedence_not.carbon  |   6 +-
 .../operators/precedence_unary.carbon         |  32 +-
 .../parse/testdata/operators/prefix.carbon    |   4 +-
 .../testdata/operators/prefix_no_space.carbon |   2 +-
 .../testdata/operators/prefix_repeat.carbon   |   8 +-
 .../recover_infix_uneven_space_before.carbon  |   2 +-
 .../operators/recover_postfix_space.carbon    |   2 +-
 .../recover_postfix_space_before_comma.carbon |   2 +-
 .../recover_postfix_space_in_call.carbon      |   2 +-
 .../recover_postfix_space_surrounding.carbon  |   2 +-
 .../operators/recover_prefix_repeat.carbon    |   6 +-
 .../operators/recover_prefix_space.carbon     |   2 +-
 ...ver_prefix_uneven_space_with_assign.carbon |   2 +-
 .../parse/testdata/operators/spaceship.carbon |   2 +-
 .../testdata/pointer/const_pointer.carbon     |  12 +-
 .../pointer/fail_pointer_type_in_expr.carbon  |  14 +-
 .../testdata/pointer/pointer_type.carbon      |   8 +-
 .../testdata/pointer/pointer_value.carbon     |  14 +-
 55 files changed, 569 insertions(+), 365 deletions(-)

diff --git a/toolchain/check/handle_operator.cpp b/toolchain/check/handle_operator.cpp
index b243a78e0b11..dfe6a406e31f 100644
--- a/toolchain/check/handle_operator.cpp
+++ b/toolchain/check/handle_operator.cpp
@@ -7,156 +7,300 @@
 
 namespace Carbon::Check {
 
-auto HandleInfixOperator(Context& context, Parse::NodeId parse_node) -> bool {
+auto HandleInfixOperatorAmp(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorAmp");
+}
+
+auto HandleInfixOperatorAmpEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorAmpEqual");
+}
+
+auto HandleInfixOperatorAs(Context& context, Parse::NodeId parse_node) -> bool {
   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);
-  switch (auto token_kind = context.tokens().GetKind(token)) {
-    case Lex::TokenKind::As: {
-      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));
-      return true;
-    }
-    case Lex::TokenKind::Equal: {
-      // TODO: handle complex assignment expression such as `a += 1`.
-      if (auto lhs_cat = SemIR::GetExprCategory(context.sem_ir(), lhs_id);
-          lhs_cat != SemIR::ExprCategory::DurableRef &&
-          lhs_cat != SemIR::ExprCategory::Error) {
-        CARBON_DIAGNOSTIC(AssignmentToNonAssignable, Error,
-                          "Expression is not assignable.");
-        context.emitter().Emit(lhs_node, AssignmentToNonAssignable);
-      }
-      // TODO: Destroy the old value before reinitializing. This will require
-      // building the destruction code before we build the RHS subexpression.
-      rhs_id = Initialize(context, parse_node, lhs_id, rhs_id);
-      context.AddInst(SemIR::Assign{parse_node, lhs_id, rhs_id});
-      // We model assignment as an expression, so we need to push a value for
-      // it, even though it doesn't produce a value.
-      // TODO: Consider changing our parse tree to model assignment as a
-      // different kind of statement than an expression statement.
-      context.node_stack().Push(parse_node, lhs_id);
-      return true;
-    }
-    default:
-      return context.TODO(parse_node, llvm::formatv("Handle {0}", token_kind));
-  }
+  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));
+  return true;
 }
 
-auto HandlePostfixOperator(Context& context, Parse::NodeId parse_node) -> bool {
-  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 = ExprAsType(context, parse_node, value_id);
-      context.AddInstAndPush(
-          parse_node, SemIR::PointerType{parse_node, SemIR::TypeId::TypeType,
-                                         inner_type_id});
-      return true;
-    }
-
-    default:
-      CARBON_FATAL() << "Unexpected postfix operator " << token_kind;
-  }
+auto HandleInfixOperatorCaret(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorCaret");
 }
 
-auto HandlePrefixOperator(Context& context, Parse::NodeId parse_node) -> bool {
+auto HandleInfixOperatorCaretEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorCaretEqual");
+}
+
+auto HandleInfixOperatorEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  auto [rhs_node, rhs_id] = context.node_stack().PopExprWithParseNode();
+  auto [lhs_node, lhs_id] = context.node_stack().PopExprWithParseNode();
+
+  // TODO: handle complex assignment expression such as `a += 1`.
+  if (auto lhs_cat = SemIR::GetExprCategory(context.sem_ir(), lhs_id);
+      lhs_cat != SemIR::ExprCategory::DurableRef &&
+      lhs_cat != SemIR::ExprCategory::Error) {
+    CARBON_DIAGNOSTIC(AssignmentToNonAssignable, Error,
+                      "Expression is not assignable.");
+    context.emitter().Emit(lhs_node, AssignmentToNonAssignable);
+  }
+  // TODO: Destroy the old value before reinitializing. This will require
+  // building the destruction code before we build the RHS subexpression.
+  rhs_id = Initialize(context, parse_node, lhs_id, rhs_id);
+  context.AddInst(SemIR::Assign{parse_node, lhs_id, rhs_id});
+  // We model assignment as an expression, so we need to push a value for
+  // it, even though it doesn't produce a value.
+  // TODO: Consider changing our parse tree to model assignment as a
+  // different kind of statement than an expression statement.
+  context.node_stack().Push(parse_node, lhs_id);
+  return true;
+}
+
+auto HandleInfixOperatorEqualEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorEqualEqual");
+}
+
+auto HandleInfixOperatorExclaimEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorExclaimEqual");
+}
+
+auto HandleInfixOperatorGreater(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorGreater");
+}
+
+auto HandleInfixOperatorGreaterEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorGreaterEqual");
+}
+
+auto HandleInfixOperatorGreaterGreater(Context& context,
+                                       Parse::NodeId parse_node) -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorGreaterGreater");
+}
+
+auto HandleInfixOperatorGreaterGreaterEqual(Context& context,
+                                            Parse::NodeId parse_node) -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorGreaterGreaterEqual");
+}
+
+auto HandleInfixOperatorLess(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorLess");
+}
+
+auto HandleInfixOperatorLessEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorLessEqual");
+}
+
+auto HandleInfixOperatorLessEqualGreater(Context& context,
+                                         Parse::NodeId parse_node) -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorLessEqualGreater");
+}
+
+auto HandleInfixOperatorLessLess(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorLessLess");
+}
+
+auto HandleInfixOperatorLessLessEqual(Context& context,
+                                      Parse::NodeId parse_node) -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorLessLessEqual");
+}
+
+auto HandleInfixOperatorMinus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorMinus");
+}
+
+auto HandleInfixOperatorMinusEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorMinusEqual");
+}
+
+auto HandleInfixOperatorPercent(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPercent");
+}
+
+auto HandleInfixOperatorPercentEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPercentEqual");
+}
+
+auto HandleInfixOperatorPipe(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPipe");
+}
+
+auto HandleInfixOperatorPipeEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPipeEqual");
+}
+
+auto HandleInfixOperatorPlus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPlus");
+}
+
+auto HandleInfixOperatorPlusEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorPlusEqual");
+}
+
+auto HandleInfixOperatorSlash(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorSlash");
+}
+
+auto HandleInfixOperatorSlashEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorSlashEqual");
+}
+
+auto HandleInfixOperatorStar(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorStar");
+}
+
+auto HandleInfixOperatorStarEqual(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandleInfixOperatorStarEqual");
+}
+
+auto HandlePostfixOperatorStar(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  auto value_id = context.node_stack().PopExpr();
+  auto inner_type_id = ExprAsType(context, parse_node, value_id);
+  context.AddInstAndPush(
+      parse_node,
+      SemIR::PointerType{parse_node, SemIR::TypeId::TypeType, inner_type_id});
+  return true;
+}
+
+auto HandlePrefixOperatorAmp(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  auto value_id = context.node_stack().PopExpr();
+  // Only durable reference expressions can have their address taken.
+  switch (SemIR::GetExprCategory(context.sem_ir(), value_id)) {
+    case SemIR::ExprCategory::DurableRef:
+    case SemIR::ExprCategory::Error:
+      break;
+    case SemIR::ExprCategory::EphemeralRef:
+      CARBON_DIAGNOSTIC(AddressOfEphemeralRef, Error,
+                        "Cannot take the address of a temporary object.");
+      context.emitter().Emit(TokenOnly(parse_node), AddressOfEphemeralRef);
+      break;
+    default:
+      CARBON_DIAGNOSTIC(AddressOfNonRef, Error,
+                        "Cannot take the address of non-reference expression.");
+      context.emitter().Emit(TokenOnly(parse_node), AddressOfNonRef);
+      break;
+  }
+  context.AddInstAndPush(
+      parse_node,
+      SemIR::AddressOf{parse_node,
+                       context.GetPointerType(
+                           parse_node, context.insts().Get(value_id).type_id()),
+                       value_id});
+  return true;
+}
+
+auto HandlePrefixOperatorCaret(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePrefixOperatorCaret");
+}
+
+auto HandlePrefixOperatorConst(Context& context, Parse::NodeId parse_node)
+    -> bool {
   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::GetExprCategory(context.sem_ir(), value_id)) {
-        case SemIR::ExprCategory::DurableRef:
-        case SemIR::ExprCategory::Error:
-          break;
-        case SemIR::ExprCategory::EphemeralRef:
-          CARBON_DIAGNOSTIC(AddressOfEphemeralRef, Error,
-                            "Cannot take the address of a temporary object.");
-          context.emitter().Emit(TokenOnly(parse_node), AddressOfEphemeralRef);
-          break;
-        default:
-          CARBON_DIAGNOSTIC(
-              AddressOfNonRef, Error,
-              "Cannot take the address of non-reference expression.");
-          context.emitter().Emit(TokenOnly(parse_node), AddressOfNonRef);
-          break;
-      }
-      context.AddInstAndPush(
-          parse_node,
-          SemIR::AddressOf{
-              parse_node,
-              context.GetPointerType(parse_node,
-                                     context.insts().Get(value_id).type_id()),
-              value_id});
-      return true;
-    }
-
-    case Lex::TokenKind::Const: {
-      // `const (const T)` is probably not what the developer intended.
-      // TODO: Detect `const (const T)*` and suggest moving the `*` inside the
-      // parentheses.
-      if (context.insts().Get(value_id).kind() == SemIR::ConstType::Kind) {
-        CARBON_DIAGNOSTIC(RepeatedConst, Warning,
-                          "`const` applied repeatedly to the same type has no "
-                          "additional effect.");
-        context.emitter().Emit(parse_node, RepeatedConst);
-      }
-      auto inner_type_id = ExprAsType(context, parse_node, value_id);
-      context.AddInstAndPush(
-          parse_node,
-          SemIR::ConstType{parse_node, SemIR::TypeId::TypeType, inner_type_id});
-      return true;
-    }
-
-    case Lex::TokenKind::Not:
-      value_id = ConvertToBoolValue(context, parse_node, value_id);
-      context.AddInstAndPush(
-          parse_node,
-          SemIR::UnaryOperatorNot{
-              parse_node, context.insts().Get(value_id).type_id(), value_id});
-      return true;
-
-    case Lex::TokenKind::Star: {
-      value_id = ConvertToValueExpr(context, value_id);
-      auto type_id =
-          context.GetUnqualifiedType(context.insts().Get(value_id).type_id());
-      auto result_type_id = SemIR::TypeId::Error;
-      if (auto pointer_type =
-              context.types().TryGetAs<SemIR::PointerType>(type_id)) {
-        result_type_id = pointer_type->pointee_id;
-      } else if (type_id != SemIR::TypeId::Error) {
-        CARBON_DIAGNOSTIC(
-            DerefOfNonPointer, Error,
-            "Cannot dereference operand of non-pointer type `{0}`.",
-            std::string);
-        auto builder =
-            context.emitter().Build(TokenOnly(parse_node), DerefOfNonPointer,
-                                    context.sem_ir().StringifyType(type_id));
-        // TODO: Check for any facet here, rather than only a type.
-        if (type_id == SemIR::TypeId::TypeType) {
-          CARBON_DIAGNOSTIC(
-              DerefOfType, Note,
-              "To form a pointer type, write the `*` after the pointee type.");
-          builder.Note(TokenOnly(parse_node), DerefOfType);
-        }
-        builder.Emit();
-      }
-      context.AddInstAndPush(
-          parse_node, SemIR::Deref{parse_node, result_type_id, value_id});
-      return true;
-    }
-
-    default:
-      return context.TODO(parse_node, llvm::formatv("Handle {0}", token_kind));
+  // `const (const T)` is probably not what the developer intended.
+  // TODO: Detect `const (const T)*` and suggest moving the `*` inside the
+  // parentheses.
+  if (context.insts().Get(value_id).kind() == SemIR::ConstType::Kind) {
+    CARBON_DIAGNOSTIC(RepeatedConst, Warning,
+                      "`const` applied repeatedly to the same type has no "
+                      "additional effect.");
+    context.emitter().Emit(parse_node, RepeatedConst);
   }
+  auto inner_type_id = ExprAsType(context, parse_node, value_id);
+  context.AddInstAndPush(
+      parse_node,
+      SemIR::ConstType{parse_node, SemIR::TypeId::TypeType, inner_type_id});
+  return true;
+}
+
+auto HandlePrefixOperatorMinus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePrefixOperatorMinus");
+}
+
+auto HandlePrefixOperatorMinusMinus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePrefixOperatorMinusMinus");
+}
+
+auto HandlePrefixOperatorNot(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  auto value_id = context.node_stack().PopExpr();
+  value_id = ConvertToBoolValue(context, parse_node, value_id);
+  context.AddInstAndPush(
+      parse_node,
+      SemIR::UnaryOperatorNot{
+          parse_node, context.insts().Get(value_id).type_id(), value_id});
+  return true;
+}
+
+auto HandlePrefixOperatorPlus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePrefixOperatorPlus");
+}
+
+auto HandlePrefixOperatorPlusPlus(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  return context.TODO(parse_node, "HandlePrefixOperatorPlusPlus");
+}
+
+auto HandlePrefixOperatorStar(Context& context, Parse::NodeId parse_node)
+    -> bool {
+  auto value_id = context.node_stack().PopExpr();
+  value_id = ConvertToValueExpr(context, value_id);
+  auto type_id =
+      context.GetUnqualifiedType(context.insts().Get(value_id).type_id());
+  auto result_type_id = SemIR::TypeId::Error;
+  if (auto pointer_type =
+          context.types().TryGetAs<SemIR::PointerType>(type_id)) {
+    result_type_id = pointer_type->pointee_id;
+  } else if (type_id != SemIR::TypeId::Error) {
+    CARBON_DIAGNOSTIC(DerefOfNonPointer, Error,
+                      "Cannot dereference operand of non-pointer type `{0}`.",
+                      std::string);
+    auto builder =
+        context.emitter().Build(TokenOnly(parse_node), DerefOfNonPointer,
+                                context.sem_ir().StringifyType(type_id));
+    // TODO: Check for any facet here, rather than only a type.
+    if (type_id == SemIR::TypeId::TypeType) {
+      CARBON_DIAGNOSTIC(
+          DerefOfType, Note,
+          "To form a pointer type, write the `*` after the pointee type.");
+      builder.Note(TokenOnly(parse_node), DerefOfType);
+    }
+    builder.Emit();
+  }
+  context.AddInstAndPush(parse_node,
+                         SemIR::Deref{parse_node, result_type_id, value_id});
+  return true;
 }
 
 // Adds the branch for a short circuit operand.
diff --git a/toolchain/check/node_stack.h b/toolchain/check/node_stack.h
index 7be0faeb801e..907af2da172b 100644
--- a/toolchain/check/node_stack.h
+++ b/toolchain/check/node_stack.h
@@ -330,12 +330,10 @@ class NodeStack {
       case Parse::NodeKind::IfExprThen:
       case Parse::NodeKind::IfExprElse:
       case Parse::NodeKind::IndexExpr:
-      case Parse::NodeKind::InfixOperator:
       case Parse::NodeKind::MemberAccessExpr:
       case Parse::NodeKind::PackageExpr:
       case Parse::NodeKind::ParenExpr:
-      case Parse::NodeKind::PostfixOperator:
-      case Parse::NodeKind::PrefixOperator:
+      case Parse::NodeKind::PostfixOperatorStar:
       case Parse::NodeKind::ReturnType:
       case Parse::NodeKind::SelfTypeNameExpr:
       case Parse::NodeKind::SelfValueNameExpr:
@@ -386,6 +384,12 @@ class NodeStack {
         return IdKind::SoloParseNode;
 // Use x-macros to handle token cases.
 #define CARBON_PARSE_NODE_KIND(...)
+#define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name, ...) \
+  case Parse::NodeKind::InfixOperator##Name:             \
+    return IdKind::InstId;
+#define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name, ...) \
+  case Parse::NodeKind::PrefixOperator##Name:             \
+    return IdKind::InstId;
 #define CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(Name, ...) \
   case Parse::NodeKind::Name:                           \
     return IdKind::InstId;
diff --git a/toolchain/check/testdata/index/fail_negative_indexing.carbon b/toolchain/check/testdata/index/fail_negative_indexing.carbon
index 32572cfd69ab..9bc1bc7ab92a 100644
--- a/toolchain/check/testdata/index/fail_negative_indexing.carbon
+++ b/toolchain/check/testdata/index/fail_negative_indexing.carbon
@@ -5,7 +5,7 @@
 // AUTOUPDATE
 
 var a: (i32, i32) = (12, 6);
-// CHECK:STDERR: fail_negative_indexing.carbon:[[@LINE+3]]:16: ERROR: Semantics TODO: `Handle -`.
+// CHECK:STDERR: fail_negative_indexing.carbon:[[@LINE+3]]:16: ERROR: Semantics TODO: `HandlePrefixOperatorMinus`.
 // CHECK:STDERR: var b: i32 = a[-10];
 // CHECK:STDERR:                ^~~
 var b: i32 = a[-10];
diff --git a/toolchain/check/testdata/operators/fail_type_mismatch_once.carbon b/toolchain/check/testdata/operators/fail_type_mismatch_once.carbon
index ed5bd53adf0e..5c65da0d2143 100644
--- a/toolchain/check/testdata/operators/fail_type_mismatch_once.carbon
+++ b/toolchain/check/testdata/operators/fail_type_mismatch_once.carbon
@@ -7,7 +7,7 @@
 fn Main() -> i32 {
   // The following line has two mismatches, but after the first, it shouldn't
   // keep erroring.
-  // CHECK:STDERR: fail_type_mismatch_once.carbon:[[@LINE+3]]:10: ERROR: Semantics TODO: `Handle +`.
+  // CHECK:STDERR: fail_type_mismatch_once.carbon:[[@LINE+3]]:10: ERROR: Semantics TODO: `HandleInfixOperatorPlus`.
   // CHECK:STDERR:   return 12 + 3.4 + 12;
   // CHECK:STDERR:          ^~~~~~~~
   return 12 + 3.4 + 12;
diff --git a/toolchain/check/testdata/operators/fail_unimplemented_op.carbon b/toolchain/check/testdata/operators/fail_unimplemented_op.carbon
index 08137f4c94cb..aa302ffc43c0 100644
--- a/toolchain/check/testdata/operators/fail_unimplemented_op.carbon
+++ b/toolchain/check/testdata/operators/fail_unimplemented_op.carbon
@@ -5,7 +5,7 @@
 // AUTOUPDATE
 
 fn Main() -> i32 {
-  // CHECK:STDERR: fail_unimplemented_op.carbon:[[@LINE+3]]:10: ERROR: Semantics TODO: `Handle +`.
+  // CHECK:STDERR: fail_unimplemented_op.carbon:[[@LINE+3]]:10: ERROR: Semantics TODO: `HandleInfixOperatorPlus`.
   // CHECK:STDERR:   return 12 + 34;
   // CHECK:STDERR:          ^~~~~~~
   return 12 + 34;
diff --git a/toolchain/parse/handle_expr.cpp b/toolchain/parse/handle_expr.cpp
index ab5f2c471831..58ffb50449e6 100644
--- a/toolchain/parse/handle_expr.cpp
+++ b/toolchain/parse/handle_expr.cpp
@@ -2,6 +2,7 @@
 // Exceptions. See /LICENSE for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include "toolchain/lex/token_kind.h"
 #include "toolchain/parse/context.h"
 
 namespace Carbon::Parse {
@@ -48,7 +49,7 @@ auto HandleExpr(Context& context) -> void {
       context.PushState(State::IfExprFinish);
       context.PushState(State::IfExprFinishCondition);
     } else {
-      context.PushStateForExprLoop(State::ExprLoopForPrefix,
+      context.PushStateForExprLoop(State::ExprLoopForPrefixOperator,
                                    state.ambient_precedence,
                                    *operator_precedence);
     }
@@ -279,44 +280,72 @@ auto HandleExprLoop(Context& context) -> void {
         break;
 
       default:
-        state.state = State::ExprLoopForBinary;
+        state.state = State::ExprLoopForInfixOperator;
         break;
     }
 
     context.PushState(state);
     context.PushStateForExpr(operator_precedence);
   } else {
-    context.AddNode(NodeKind::PostfixOperator, state.token, state.subtree_start,
-                    state.has_error);
+    context.AddNode(NodeKind::PostfixOperatorStar, state.token,
+                    state.subtree_start, state.has_error);
     state.has_error = false;
     context.PushState(state);
   }
 }
 
 // Adds the operator node and returns the the main expression loop.
-static auto HandleExprLoopForOperator(Context& context, NodeKind node_kind)
-    -> void {
-  auto state = context.PopState();
-
+static auto HandleExprLoopForOperator(Context& context,
+                                      Context::StateStackEntry state,
+                                      NodeKind node_kind) -> void {
   context.AddNode(node_kind, state.token, state.subtree_start, state.has_error);
   state.has_error = false;
   context.PushState(state, State::ExprLoop);
 }
 
-auto HandleExprLoopForBinary(Context& context) -> void {
-  HandleExprLoopForOperator(context, NodeKind::InfixOperator);
+auto HandleExprLoopForInfixOperator(Context& context) -> void {
+  auto state = context.PopState();
+
+  switch (auto token_kind = context.tokens().GetKind(state.token)) {
+#define CARBON_PARSE_NODE_KIND(...)
+#define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name, ...)                      \
+  case Lex::TokenKind::Name:                                                  \
+    HandleExprLoopForOperator(context, state, NodeKind::InfixOperator##Name); \
+    break;
+#include "toolchain/parse/node_kind.def"
+
+    default:
+      CARBON_FATAL() << "Unexpected token kind for infix operator: "
+                     << token_kind;
+  }
 }
 
-auto HandleExprLoopForPrefix(Context& context) -> void {
-  HandleExprLoopForOperator(context, NodeKind::PrefixOperator);
+auto HandleExprLoopForPrefixOperator(Context& context) -> void {
+  auto state = context.PopState();
+
+  switch (auto token_kind = context.tokens().GetKind(state.token)) {
+#define CARBON_PARSE_NODE_KIND(...)
+#define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name, ...)                      \
+  case Lex::TokenKind::Name:                                                   \
+    HandleExprLoopForOperator(context, state, NodeKind::PrefixOperator##Name); \
+    break;
+#include "toolchain/parse/node_kind.def"
+
+    default:
+      CARBON_FATAL() << "Unexpected token kind for prefix operator: "
+                     << token_kind;
+  }
 }
 
 auto HandleExprLoopForShortCircuitOperatorAsAnd(Context& context) -> void {
-  HandleExprLoopForOperator(context, NodeKind::ShortCircuitOperatorAnd);
+  auto state = context.PopState();
+  HandleExprLoopForOperator(context, state, NodeKind::ShortCircuitOperatorAnd);
 }
 
 auto HandleExprLoopForShortCircuitOperatorAsOr(Context& context) -> void {
-  HandleExprLoopForOperator(context, NodeKind::ShortCircuitOperatorOr);
+  auto state = context.PopState();
+
+  HandleExprLoopForOperator(context, state, NodeKind::ShortCircuitOperatorOr);
 }
 
 auto HandleIfExprFinishCondition(Context& context) -> void {
diff --git a/toolchain/parse/node_kind.def b/toolchain/parse/node_kind.def
index c7de6f289f10..648c7c3fcdf4 100644
--- a/toolchain/parse/node_kind.def
+++ b/toolchain/parse/node_kind.def
@@ -17,6 +17,10 @@
 //   - CARBON_PARSE_NODE_KIND_CHILD_COUNT(Name, ChildCount, LexTokenKinds)
 //     Defines a parse node with a set number of children, often 0. This count
 //     must be correct even when the node contains errors.
+//   - CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name)
+//     Defines a parse node for an infix operator, with the Name as token.
+//   - CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name)
+//     Defines a parse node for a prefix operator, with the Name as token.
 //   - CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(Name, LexTokenKinds)
 //     Defines a parse node that corresponds to a token that is a single-token
 //     literal. The token is wrapped for LexTokenKinds.
@@ -53,6 +57,28 @@
   CARBON_PARSE_NODE_KIND(Name)
 #endif
 
+// This is expected to be used with something like:
+//
+//   // Use x-macros to handle modifier cases.
+//   #define CARBON_PARSE_NODE_KIND(...)
+//   #define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name, ...) <code>
+#ifndef CARBON_PARSE_NODE_KIND_INFIX_OPERATOR
+#define CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Name) \
+  CARBON_PARSE_NODE_KIND_CHILD_COUNT(InfixOperator##Name, 2, \
+                                     CARBON_TOKEN(Name))
+#endif
+
+// This is expected to be used with something like:
+//
+//   // Use x-macros to handle modifier cases.
+//   #define CARBON_PARSE_NODE_KIND(...)
+//   #define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name, ...) <code>
+#ifndef CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR
+#define CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Name) \
+  CARBON_PARSE_NODE_KIND_CHILD_COUNT(PrefixOperator##Name, 1, \
+                                     CARBON_TOKEN(Name))
+#endif
+
 // This is expected to be used with something like:
 //
 //   // Use x-macros to handle literal cases.
@@ -511,70 +537,69 @@ CARBON_PARSE_NODE_KIND_TOKEN_LITERAL(TypeTypeLiteral, CARBON_TOKEN(Type))
 
 // clang-format off
 
-// A prefix operator:
+// A prefix operator, such as `not`:
 //   _external_: expression
-// PrefixOperator
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(PrefixOperator, 1,
-                                   CARBON_TOKEN(Star)
-                                   CARBON_TOKEN(Amp)
-                                   CARBON_TOKEN(Not)
-                                   CARBON_TOKEN(Minus)
-                                   CARBON_TOKEN(MinusMinus)
-                                   CARBON_TOKEN(PlusPlus)
-                                   CARBON_TOKEN(Caret)
-                                   CARBON_TOKEN(Const))
+// PrefixOperator<name>
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Amp)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Caret)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Const)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Not)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Minus)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(MinusMinus)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(PlusPlus)
+CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR(Star)
 
-// An infix operator:
+// An infix operator, such as `+`:
 //   _external_: lhs expression
 //   _external_: rhs expression
-// InfixOperator
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(InfixOperator, 2,
-                                   CARBON_TOKEN(Amp)
-                                   CARBON_TOKEN(AmpEqual)
-                                   CARBON_TOKEN(As)
-                                   CARBON_TOKEN(Caret)
-                                   CARBON_TOKEN(CaretEqual)
-                                   CARBON_TOKEN(Equal)
-                                   CARBON_TOKEN(EqualEqual)
-                                   CARBON_TOKEN(ExclaimEqual)
-                                   CARBON_TOKEN(Greater)
-                                   CARBON_TOKEN(GreaterEqual)
-                                   CARBON_TOKEN(GreaterGreater)
-                                   CARBON_TOKEN(GreaterGreaterEqual)
-                                   CARBON_TOKEN(Less)
-                                   CARBON_TOKEN(LessEqual)
-                                   CARBON_TOKEN(LessEqualGreater)
-                                   CARBON_TOKEN(LessLess)
-                                   CARBON_TOKEN(LessLessEqual)
-                                   CARBON_TOKEN(Minus)
-                                   CARBON_TOKEN(MinusEqual)
-                                   CARBON_TOKEN(Percent)
-                                   CARBON_TOKEN(PercentEqual)
-                                   CARBON_TOKEN(Pipe)
-                                   CARBON_TOKEN(PipeEqual)
-                                   CARBON_TOKEN(Plus)
-                                   CARBON_TOKEN(PlusEqual)
-                                   CARBON_TOKEN(Slash)
-                                   CARBON_TOKEN(SlashEqual)
-                                   CARBON_TOKEN(Star)
-                                   CARBON_TOKEN(StarEqual))
+// InfixOperator<name>
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Amp)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(AmpEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(As)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Caret)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(CaretEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Equal)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(EqualEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(ExclaimEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Greater)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterGreater)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(GreaterGreaterEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Less)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessEqualGreater)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessLess)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(LessLessEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Minus)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(MinusEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Percent)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PercentEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Pipe)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PipeEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Plus)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(PlusEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Slash)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(SlashEqual)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(Star)
+CARBON_PARSE_NODE_KIND_INFIX_OPERATOR(StarEqual)
 
 // clang-format on
 
-// A short-circuiting infix operator:
+// A short-circuiting infix operator, such as `and`:
 //     _external_: expression
 //   ShortCircuitOperand(And|Or)
 //   _external_: expression
 // ShortCircuitOperand(And|Or)
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperandAnd, 1, CARBON_TOKEN(And))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperandOr, 1, CARBON_TOKEN(Or))
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperatorAnd, 2, CARBON_TOKEN(And))
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperatorAnd, 2,
+                                   CARBON_TOKEN(And))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ShortCircuitOperatorOr, 2, CARBON_TOKEN(Or))
 
-// A postfix operator:
+// A postfix operator, currently only `*`:
 //   _external_: expression
-// PostfixOperator
-CARBON_PARSE_NODE_KIND_CHILD_COUNT(PostfixOperator, 1, CARBON_TOKEN(Star))
+// PostfixOperatorStar
+CARBON_PARSE_NODE_KIND_CHILD_COUNT(PostfixOperatorStar, 1, CARBON_TOKEN(Star))
 
 // `if` expression + `then` + `else`:
 //     _external_: expression
@@ -747,6 +772,8 @@ CARBON_PARSE_NODE_KIND_BRACKET(NamedConstraintDecl, NamedConstraintIntroducer,
 #undef CARBON_PARSE_NODE_KIND
 #undef CARBON_PARSE_NODE_KIND_BRACKET
 #undef CARBON_PARSE_NODE_KIND_CHILD_COUNT
+#undef CARBON_PARSE_NODE_KIND_INFIX_OPERATOR
+#undef CARBON_PARSE_NODE_KIND_PREFIX_OPERATOR
 #undef CARBON_PARSE_NODE_KIND_TOKEN_LITERAL
 #undef CARBON_PARSE_NODE_KIND_TOKEN_MODIFIER
 #undef CARBON_TOKEN
diff --git a/toolchain/parse/state.def b/toolchain/parse/state.def
index c146a3192a5b..b45547b8fd40 100644
--- a/toolchain/parse/state.def
+++ b/toolchain/parse/state.def
@@ -501,7 +501,7 @@ CARBON_PARSE_STATE(ExprLoop)
 // expr <infix operator> expr ...
 //                           ^
 //   1. ExprLoop
-CARBON_PARSE_STATE(ExprLoopForBinary)
+CARBON_PARSE_STATE(ExprLoopForInfixOperator)
 
 // Completes an ExprLoop pass by adding a prefix operator, then goes back
 // to ExprLoop.
@@ -509,7 +509,7 @@ CARBON_PARSE_STATE(ExprLoopForBinary)
 // <prefix operator> expr ...
 //                       ^
 //   1. ExprLoop
-CARBON_PARSE_STATE(ExprLoopForPrefix)
+CARBON_PARSE_STATE(ExprLoopForPrefixOperator)
 
 // Completes an ExprLoop pass by adding a short circuit operator, then goes back
 // to ExprLoop.
diff --git a/toolchain/parse/testdata/class/fn_definitions.carbon b/toolchain/parse/testdata/class/fn_definitions.carbon
index f7b4e7f75897..e1647790c0d6 100644
--- a/toolchain/parse/testdata/class/fn_definitions.carbon
+++ b/toolchain/parse/testdata/class/fn_definitions.carbon
@@ -57,7 +57,7 @@ class Foo {
 // CHECK:STDOUT:             {kind: 'ImplicitParamListStart', text: '['},
 // CHECK:STDOUT:                 {kind: 'SelfValueName', text: 'self'},
 // CHECK:STDOUT:                   {kind: 'SelfTypeNameExpr', text: 'Self'},
-// CHECK:STDOUT:                 {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:             {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
@@ -68,7 +68,7 @@ class Foo {
 // CHECK:STDOUT:               {kind: 'IdentifierName', text: 'x'},
 // CHECK:STDOUT:             {kind: 'PointerMemberAccessExpr', text: '->', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '1'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '=', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'InfixOperatorEqual', text: '=', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'FunctionDefinition', text: '}', subtree_size: 19},
 // CHECK:STDOUT:     {kind: 'ClassDefinition', text: '}', subtree_size: 57},
diff --git a/toolchain/parse/testdata/function/declaration/addr.carbon b/toolchain/parse/testdata/function/declaration/addr.carbon
index df34b36e46e2..d3683525c472 100644
--- a/toolchain/parse/testdata/function/declaration/addr.carbon
+++ b/toolchain/parse/testdata/function/declaration/addr.carbon
@@ -14,7 +14,7 @@ fn foo(addr a: i32*);
 // CHECK:STDOUT:         {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'a'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'TuplePattern', text: ')', subtree_size: 7},
diff --git a/toolchain/parse/testdata/function/definition/with_params.carbon b/toolchain/parse/testdata/function/definition/with_params.carbon
index cf6494bd539b..0b873289156d 100644
--- a/toolchain/parse/testdata/function/definition/with_params.carbon
+++ b/toolchain/parse/testdata/function/definition/with_params.carbon
@@ -29,7 +29,7 @@ fn foo(bar: i64, baz: i64) {
 // CHECK:STDOUT:           {kind: 'CallExprComma', text: ','},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'bar'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'baz'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '+', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'InfixOperatorPlus', text: '+', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 8},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
diff --git a/toolchain/parse/testdata/generics/interface/default_fn.carbon b/toolchain/parse/testdata/generics/interface/default_fn.carbon
index cb31079cceff..24ca7845ac92 100644
--- a/toolchain/parse/testdata/generics/interface/default_fn.carbon
+++ b/toolchain/parse/testdata/generics/interface/default_fn.carbon
@@ -53,7 +53,7 @@ interface Foo {
 // CHECK:STDOUT:               {kind: 'MemberAccessExpr', text: '.', subtree_size: 3},
 // CHECK:STDOUT:             {kind: 'CallExprStart', text: '(', subtree_size: 4},
 // CHECK:STDOUT:               {kind: 'IntLiteral', text: '1'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CallExpr', text: ')', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'ReturnStatement', text: ';', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'FunctionDefinition', text: '}', subtree_size: 23},
diff --git a/toolchain/parse/testdata/generics/interface/self_pointer.carbon b/toolchain/parse/testdata/generics/interface/self_pointer.carbon
index dbb3bb99c02e..dd4cb2e640a5 100644
--- a/toolchain/parse/testdata/generics/interface/self_pointer.carbon
+++ b/toolchain/parse/testdata/generics/interface/self_pointer.carbon
@@ -20,7 +20,7 @@ interface Foo {
 // CHECK:STDOUT:           {kind: 'ImplicitParamListStart', text: '['},
 // CHECK:STDOUT:               {kind: 'SelfValueName', text: 'self'},
 // CHECK:STDOUT:                 {kind: 'SelfTypeNameExpr', text: 'Self'},
-// CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
@@ -37,7 +37,7 @@ interface Foo {
 // CHECK:STDOUT:           {kind: 'ImplicitParamListStart', text: '['},
 // CHECK:STDOUT:               {kind: 'SelfValueName', text: 'self'},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'foo'},
-// CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'Address', text: 'addr', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ImplicitParamList', text: ']', subtree_size: 7},
diff --git a/toolchain/parse/testdata/if_expr/in_type.carbon b/toolchain/parse/testdata/if_expr/in_type.carbon
index 772daa475c87..fdbaf4fff32e 100644
--- a/toolchain/parse/testdata/if_expr/in_type.carbon
+++ b/toolchain/parse/testdata/if_expr/in_type.carbon
@@ -27,7 +27,7 @@ fn F() -> if true then i32 else i32* {
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
 // CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // 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},
@@ -37,7 +37,7 @@ fn F() -> if true then i32 else i32* {
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:           {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '&', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorAmp', text: '&', subtree_size: 2},
 // 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},
diff --git a/toolchain/parse/testdata/operators/assign.carbon b/toolchain/parse/testdata/operators/assign.carbon
index 19c729592ddd..9d9e6af4e504 100644
--- a/toolchain/parse/testdata/operators/assign.carbon
+++ b/toolchain/parse/testdata/operators/assign.carbon
@@ -46,53 +46,53 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '*=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorStarEqual', text: '*=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '/=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorSlashEqual', text: '/=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlusEqual', text: '+=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '-=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorMinusEqual', text: '-=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '%=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPercentEqual', text: '%=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '&=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAmpEqual', text: '&=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '|=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPipeEqual', text: '|=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '^=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorCaretEqual', text: '^=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '<<=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorLessLessEqual', text: '<<=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '>>=', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorGreaterGreaterEqual', text: '>>=', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '++', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorPlusPlus', text: '++', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '--', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorMinusMinus', text: '--', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 70},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fail_chained_assign.carbon b/toolchain/parse/testdata/operators/fail_chained_assign.carbon
index 3c87e3dbfe36..cb9cf74739ac 100644
--- a/toolchain/parse/testdata/operators/fail_chained_assign.carbon
+++ b/toolchain/parse/testdata/operators/fail_chained_assign.carbon
@@ -35,9 +35,9 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 5},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '=', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'InfixOperatorEqual', text: '=', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'IntLiteral', text: '1'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fail_infix_uneven_space_after.carbon b/toolchain/parse/testdata/operators/fail_infix_uneven_space_after.carbon
index bae33a7cc3fb..7a20ccbd347f 100644
--- a/toolchain/parse/testdata/operators/fail_infix_uneven_space_after.carbon
+++ b/toolchain/parse/testdata/operators/fail_infix_uneven_space_after.carbon
@@ -20,7 +20,7 @@ var n: i8 = n* n;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', has_error: yes, subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/fail_invalid_infix.carbon b/toolchain/parse/testdata/operators/fail_invalid_infix.carbon
index 0331db0501d4..6d56f513f554 100644
--- a/toolchain/parse/testdata/operators/fail_invalid_infix.carbon
+++ b/toolchain/parse/testdata/operators/fail_invalid_infix.carbon
@@ -30,7 +30,7 @@ var c: i32 = == ;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '==', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorEqualEqual', text: '==', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'b'},
@@ -39,7 +39,7 @@ var c: i32 = == ;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: '==', has_error: yes},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '==', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorEqualEqual', text: '==', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'c'},
@@ -48,7 +48,7 @@ var c: i32 = == ;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: '==', has_error: yes},
 // CHECK:STDOUT:         {kind: 'InvalidParse', text: ';', has_error: yes},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '==', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorEqualEqual', text: '==', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/fail_precedence_as.carbon b/toolchain/parse/testdata/operators/fail_precedence_as.carbon
index e8f2075a0694..1feccab1a40f 100644
--- a/toolchain/parse/testdata/operators/fail_precedence_as.carbon
+++ b/toolchain/parse/testdata/operators/fail_precedence_as.carbon
@@ -34,21 +34,21 @@ fn F(n: i32) {
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 8},
 // CHECK:STDOUT:             {kind: 'BoolLiteralTrue', text: 'true'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BoolTypeLiteral', text: 'bool'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAs', text: 'as', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '1'},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '1'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '+', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'InfixOperatorPlus', text: '+', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAs', text: 'as', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '5'},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '2'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '%', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'InfixOperatorPercent', text: '%', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAs', text: 'as', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 26},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fail_precedence_assign.carbon b/toolchain/parse/testdata/operators/fail_precedence_assign.carbon
index 8aaeaad5081a..1463e90fc005 100644
--- a/toolchain/parse/testdata/operators/fail_precedence_assign.carbon
+++ b/toolchain/parse/testdata/operators/fail_precedence_assign.carbon
@@ -46,7 +46,7 @@ fn F() {
 // CHECK:STDOUT:             {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'ParenExpr', text: ')', has_error: yes, subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', subtree_size: 5},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlus', text: '+', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:               {kind: 'BoolLiteralTrue', text: 'true'},
@@ -59,8 +59,8 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 9},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'a'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '++', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', subtree_size: 4},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorPlusPlus', text: '++', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlus', text: '+', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'c'},
 // CHECK:STDOUT:             {kind: 'IfExprIf', text: 'if', subtree_size: 2},
@@ -68,7 +68,7 @@ fn F() {
 // CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'b'},
 // CHECK:STDOUT:           {kind: 'IfExprElse', text: 'else', subtree_size: 6},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '++', subtree_size: 7},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorPlusPlus', text: '++', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 39},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fail_precedence_star_minus.carbon b/toolchain/parse/testdata/operators/fail_precedence_star_minus.carbon
index 3807eb8165e6..4621835bb1b8 100644
--- a/toolchain/parse/testdata/operators/fail_precedence_star_minus.carbon
+++ b/toolchain/parse/testdata/operators/fail_precedence_star_minus.carbon
@@ -18,9 +18,9 @@ var n: i8 = n* -n;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '-', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:       {kind: 'InfixOperatorMinus', text: '-', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/fail_precedence_star_star.carbon b/toolchain/parse/testdata/operators/fail_precedence_star_star.carbon
index 3ceb7da96b51..6606afd797e9 100644
--- a/toolchain/parse/testdata/operators/fail_precedence_star_star.carbon
+++ b/toolchain/parse/testdata/operators/fail_precedence_star_star.carbon
@@ -18,9 +18,9 @@ var n: i8 = n* *p;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/fail_star_star_no_space.carbon b/toolchain/parse/testdata/operators/fail_star_star_no_space.carbon
index fc2b9ddb589c..0eafc7f83511 100644
--- a/toolchain/parse/testdata/operators/fail_star_star_no_space.carbon
+++ b/toolchain/parse/testdata/operators/fail_star_star_no_space.carbon
@@ -22,8 +22,8 @@ var n: i8 = n**p;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', has_error: yes, subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/fail_variety.carbon b/toolchain/parse/testdata/operators/fail_variety.carbon
index 1c55fe4844a9..1e50b403f62f 100644
--- a/toolchain/parse/testdata/operators/fail_variety.carbon
+++ b/toolchain/parse/testdata/operators/fail_variety.carbon
@@ -34,23 +34,23 @@ fn F() {
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:               {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:               {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'c'},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'd'},
-// CHECK:STDOUT:               {kind: 'InfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:             {kind: 'InfixOperator', text: '+', subtree_size: 7},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '=', subtree_size: 9},
+// CHECK:STDOUT:               {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'InfixOperatorPlus', text: '+', subtree_size: 7},
+// CHECK:STDOUT:           {kind: 'InfixOperatorEqual', text: '=', subtree_size: 9},
 // CHECK:STDOUT:                   {kind: 'IdentifierNameExpr', text: 'd'},
 // CHECK:STDOUT:                   {kind: 'IdentifierNameExpr', text: 'd'},
-// CHECK:STDOUT:                 {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:                 {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'e'},
-// CHECK:STDOUT:               {kind: 'InfixOperator', text: '<<', has_error: yes, subtree_size: 5},
+// CHECK:STDOUT:               {kind: 'InfixOperatorLessLess', text: '<<', has_error: yes, subtree_size: 5},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'f'},
-// CHECK:STDOUT:             {kind: 'InfixOperator', text: '&', has_error: yes, subtree_size: 7},
+// CHECK:STDOUT:             {kind: 'InfixOperatorAmp', text: '&', has_error: yes, subtree_size: 7},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'g'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '-', has_error: yes, subtree_size: 10},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', has_error: yes, subtree_size: 20},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'InfixOperatorMinus', text: '-', has_error: yes, subtree_size: 10},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', has_error: yes, subtree_size: 20},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 21},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 27},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fixity_in_call.carbon b/toolchain/parse/testdata/operators/fixity_in_call.carbon
index 435b6fc5ed5e..c437d2a72f22 100644
--- a/toolchain/parse/testdata/operators/fixity_in_call.carbon
+++ b/toolchain/parse/testdata/operators/fixity_in_call.carbon
@@ -19,11 +19,11 @@ fn F() {
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'G'},
 // CHECK:STDOUT:           {kind: 'CallExprStart', text: '(', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'CallExprComma', text: ','},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'CallExpr', text: ')', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 16},
diff --git a/toolchain/parse/testdata/operators/fixity_in_params.carbon b/toolchain/parse/testdata/operators/fixity_in_params.carbon
index 31fb3c73fc87..d7f4f6df2ad7 100644
--- a/toolchain/parse/testdata/operators/fixity_in_params.carbon
+++ b/toolchain/parse/testdata/operators/fixity_in_params.carbon
@@ -15,7 +15,7 @@ fn F(p: i32*, n: i32) {
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'p'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'PatternListComma', text: ','},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'n'},
diff --git a/toolchain/parse/testdata/operators/fixity_in_var.carbon b/toolchain/parse/testdata/operators/fixity_in_var.carbon
index ea0cad2b6d56..14c2e93ae027 100644
--- a/toolchain/parse/testdata/operators/fixity_in_var.carbon
+++ b/toolchain/parse/testdata/operators/fixity_in_var.carbon
@@ -20,7 +20,7 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'IdentifierName', text: 'q'},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'p'},
@@ -31,7 +31,7 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 22},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/fixity_with_assign.carbon b/toolchain/parse/testdata/operators/fixity_with_assign.carbon
index d4c0f4dc0436..b6167284c526 100644
--- a/toolchain/parse/testdata/operators/fixity_with_assign.carbon
+++ b/toolchain/parse/testdata/operators/fixity_with_assign.carbon
@@ -21,28 +21,28 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 't'},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 't'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 5},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '*', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 6},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'InfixOperatorStar', text: '*', subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 7},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'InfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 31},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/infix.carbon b/toolchain/parse/testdata/operators/infix.carbon
index 7cc2e822c166..6c9ac44ceb0c 100644
--- a/toolchain/parse/testdata/operators/infix.carbon
+++ b/toolchain/parse/testdata/operators/infix.carbon
@@ -16,7 +16,7 @@ var n: i8 = n * n;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/infix_no_space.carbon b/toolchain/parse/testdata/operators/infix_no_space.carbon
index 71df14dfe8a9..d29ed470ae7c 100644
--- a/toolchain/parse/testdata/operators/infix_no_space.carbon
+++ b/toolchain/parse/testdata/operators/infix_no_space.carbon
@@ -16,7 +16,7 @@ var n: i8 = n*n;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/infix_with_paren_after.carbon b/toolchain/parse/testdata/operators/infix_with_paren_after.carbon
index 4e086e1331a5..636444d291ba 100644
--- a/toolchain/parse/testdata/operators/infix_with_paren_after.carbon
+++ b/toolchain/parse/testdata/operators/infix_with_paren_after.carbon
@@ -18,7 +18,7 @@ var n: i8 = 3*(n);
 // CHECK:STDOUT:           {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'ParenExpr', text: ')', subtree_size: 3},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', subtree_size: 5},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/infix_with_paren_before.carbon b/toolchain/parse/testdata/operators/infix_with_paren_before.carbon
index 3aac9565bc86..e9f2cad179e2 100644
--- a/toolchain/parse/testdata/operators/infix_with_paren_before.carbon
+++ b/toolchain/parse/testdata/operators/infix_with_paren_before.carbon
@@ -18,7 +18,7 @@ var n: i8 = (n)*3;
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'ParenExpr', text: ')', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'IntLiteral', text: '3'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', subtree_size: 5},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/postfix.carbon b/toolchain/parse/testdata/operators/postfix.carbon
index 15ab6ad1614e..f8d9ebcc5d68 100644
--- a/toolchain/parse/testdata/operators/postfix.carbon
+++ b/toolchain/parse/testdata/operators/postfix.carbon
@@ -15,7 +15,7 @@ var v: type = i8*;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/postfix_repeat.carbon b/toolchain/parse/testdata/operators/postfix_repeat.carbon
index 2e8d8065a270..35b8b3363837 100644
--- a/toolchain/parse/testdata/operators/postfix_repeat.carbon
+++ b/toolchain/parse/testdata/operators/postfix_repeat.carbon
@@ -17,10 +17,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:                 {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 5},
+// CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', 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: ''},
diff --git a/toolchain/parse/testdata/operators/postfix_space_after_op.carbon b/toolchain/parse/testdata/operators/postfix_space_after_op.carbon
index 45271cd0ba1a..51f683e26bf1 100644
--- a/toolchain/parse/testdata/operators/postfix_space_after_op.carbon
+++ b/toolchain/parse/testdata/operators/postfix_space_after_op.carbon
@@ -15,7 +15,7 @@ var v: type = i8* ;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/precedence_as.carbon b/toolchain/parse/testdata/operators/precedence_as.carbon
index 52779be973e0..795545f4c22f 100644
--- a/toolchain/parse/testdata/operators/precedence_as.carbon
+++ b/toolchain/parse/testdata/operators/precedence_as.carbon
@@ -26,34 +26,34 @@ fn F(n: i32) {
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 8},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: 'const', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAs', text: 'as', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '&', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorAmp', text: '&', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: 'as', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'InfixOperatorAs', text: 'as', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'IfConditionStart', text: '('},
 // CHECK:STDOUT:                       {kind: 'IntLiteral', text: '1'},
 // CHECK:STDOUT:                       {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:                     {kind: 'InfixOperator', text: 'as', subtree_size: 3},
+// CHECK:STDOUT:                     {kind: 'InfixOperatorAs', text: 'as', subtree_size: 3},
 // CHECK:STDOUT:                       {kind: 'IntLiteral', text: '2'},
 // CHECK:STDOUT:                       {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:                     {kind: 'InfixOperator', text: 'as', subtree_size: 3},
-// CHECK:STDOUT:                   {kind: 'InfixOperator', text: '<', subtree_size: 7},
+// CHECK:STDOUT:                     {kind: 'InfixOperatorAs', text: 'as', subtree_size: 3},
+// CHECK:STDOUT:                   {kind: 'InfixOperatorLess', text: '<', subtree_size: 7},
 // CHECK:STDOUT:                 {kind: 'ShortCircuitOperandAnd', text: 'and', subtree_size: 8},
 // CHECK:STDOUT:                   {kind: 'BoolLiteralTrue', text: 'true'},
 // CHECK:STDOUT:                   {kind: 'BoolTypeLiteral', text: 'bool'},
-// CHECK:STDOUT:                 {kind: 'InfixOperator', text: 'as', subtree_size: 3},
+// CHECK:STDOUT:                 {kind: 'InfixOperatorAs', text: 'as', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperatorAnd', text: 'and', subtree_size: 12},
 // CHECK:STDOUT:             {kind: 'ShortCircuitOperandAnd', text: 'and', subtree_size: 13},
 // CHECK:STDOUT:               {kind: 'BoolLiteralFalse', text: 'false'},
 // CHECK:STDOUT:               {kind: 'BoolTypeLiteral', text: 'bool'},
-// CHECK:STDOUT:             {kind: 'InfixOperator', text: 'as', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'InfixOperatorAs', text: 'as', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'ShortCircuitOperatorAnd', text: 'and', subtree_size: 17},
 // CHECK:STDOUT:         {kind: 'IfCondition', text: ')', subtree_size: 19},
 // CHECK:STDOUT:           {kind: 'CodeBlockStart', text: '{'},
diff --git a/toolchain/parse/testdata/operators/precedence_assign.carbon b/toolchain/parse/testdata/operators/precedence_assign.carbon
index 5d3dd1053ff3..97a7801e40dc 100644
--- a/toolchain/parse/testdata/operators/precedence_assign.carbon
+++ b/toolchain/parse/testdata/operators/precedence_assign.carbon
@@ -37,18 +37,18 @@ fn F(c: bool) {
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'IdentifierName', text: 'p'},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 6},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'c'},
 // CHECK:STDOUT:             {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'IntLiteral', text: '1'},
 // CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '2'},
 // CHECK:STDOUT:           {kind: 'IfExprElse', text: 'else', subtree_size: 6},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '=', subtree_size: 9},
+// CHECK:STDOUT:         {kind: 'InfixOperatorEqual', text: '=', subtree_size: 9},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 10},
 // CHECK:STDOUT:             {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'c'},
@@ -64,7 +64,7 @@ fn F(c: bool) {
 // CHECK:STDOUT:             {kind: 'IfExprThen', text: 'then', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntLiteral', text: '2'},
 // CHECK:STDOUT:           {kind: 'IfExprElse', text: 'else', subtree_size: 6},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+=', subtree_size: 15},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlusEqual', text: '+=', subtree_size: 15},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 16},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 51},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/precedence_not.carbon b/toolchain/parse/testdata/operators/precedence_not.carbon
index 4ded7e5d02ac..f73015ea5774 100644
--- a/toolchain/parse/testdata/operators/precedence_not.carbon
+++ b/toolchain/parse/testdata/operators/precedence_not.carbon
@@ -17,14 +17,14 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:                   {kind: 'IdentifierNameExpr', text: 'a'},
-// CHECK:STDOUT:                 {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:                 {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'ShortCircuitOperandAnd', text: 'and', subtree_size: 3},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:               {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'ShortCircuitOperatorAnd', text: 'and', subtree_size: 6},
 // CHECK:STDOUT:           {kind: 'ShortCircuitOperandAnd', text: 'and', subtree_size: 7},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'c'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'ShortCircuitOperatorAnd', text: 'and', subtree_size: 10},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 17},
diff --git a/toolchain/parse/testdata/operators/precedence_unary.carbon b/toolchain/parse/testdata/operators/precedence_unary.carbon
index f01225e578c0..8c6039404a42 100644
--- a/toolchain/parse/testdata/operators/precedence_unary.carbon
+++ b/toolchain/parse/testdata/operators/precedence_unary.carbon
@@ -21,33 +21,33 @@ fn F(p: i32*) {
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'p'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 9},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '-', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '^', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', subtree_size: 7},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorCaret', text: '^', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlus', text: '+', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '-', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '^', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '|', subtree_size: 7},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorCaret', text: '^', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPipe', text: '|', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '-', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 3},
 // CHECK:STDOUT:               {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '^', subtree_size: 3},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '<<', subtree_size: 7},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorCaret', text: '^', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorLessLess', text: '<<', subtree_size: 7},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 34},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/prefix.carbon b/toolchain/parse/testdata/operators/prefix.carbon
index 99e287b53d16..362461a50755 100644
--- a/toolchain/parse/testdata/operators/prefix.carbon
+++ b/toolchain/parse/testdata/operators/prefix.carbon
@@ -16,7 +16,7 @@ var b: bool = not true;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:       {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:         {kind: 'IdentifierName', text: 'b'},
@@ -24,7 +24,7 @@ var b: bool = not true;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'BoolLiteralTrue', text: 'true'},
-// CHECK:STDOUT:       {kind: 'PrefixOperator', text: 'not', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PrefixOperatorNot', text: 'not', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/prefix_no_space.carbon b/toolchain/parse/testdata/operators/prefix_no_space.carbon
index c80bb43670d0..c235e2f2cacd 100644
--- a/toolchain/parse/testdata/operators/prefix_no_space.carbon
+++ b/toolchain/parse/testdata/operators/prefix_no_space.carbon
@@ -16,7 +16,7 @@ var n: i8 =-n;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/prefix_repeat.carbon b/toolchain/parse/testdata/operators/prefix_repeat.carbon
index 457398eed6ea..1d6d25d64953 100644
--- a/toolchain/parse/testdata/operators/prefix_repeat.carbon
+++ b/toolchain/parse/testdata/operators/prefix_repeat.carbon
@@ -17,10 +17,10 @@ fn F() {
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:                 {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:               {kind: 'PrefixOperator', text: '&', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '*', subtree_size: 4},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '*', subtree_size: 5},
+// CHECK:STDOUT:               {kind: 'PrefixOperatorAmp', text: '&', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorStar', text: '*', subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorStar', 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: ''},
diff --git a/toolchain/parse/testdata/operators/recover_infix_uneven_space_before.carbon b/toolchain/parse/testdata/operators/recover_infix_uneven_space_before.carbon
index c9d08145ec1f..754f193c3d4a 100644
--- a/toolchain/parse/testdata/operators/recover_infix_uneven_space_before.carbon
+++ b/toolchain/parse/testdata/operators/recover_infix_uneven_space_before.carbon
@@ -19,7 +19,7 @@ var n: i8 = n *n;
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'InfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:       {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/recover_postfix_space.carbon b/toolchain/parse/testdata/operators/recover_postfix_space.carbon
index 4182886764d5..2b0b16cbcfab 100644
--- a/toolchain/parse/testdata/operators/recover_postfix_space.carbon
+++ b/toolchain/parse/testdata/operators/recover_postfix_space.carbon
@@ -18,7 +18,7 @@ var v: type = i8 *;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/recover_postfix_space_before_comma.carbon b/toolchain/parse/testdata/operators/recover_postfix_space_before_comma.carbon
index 57fff92a567b..8424297e7915 100644
--- a/toolchain/parse/testdata/operators/recover_postfix_space_before_comma.carbon
+++ b/toolchain/parse/testdata/operators/recover_postfix_space_before_comma.carbon
@@ -20,7 +20,7 @@ var n: i8 = F(i8 *, 0);
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'F'},
 // CHECK:STDOUT:         {kind: 'CallExprStart', text: '(', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'CallExprComma', text: ','},
 // CHECK:STDOUT:         {kind: 'IntLiteral', text: '0'},
 // CHECK:STDOUT:       {kind: 'CallExpr', text: ')', subtree_size: 7},
diff --git a/toolchain/parse/testdata/operators/recover_postfix_space_in_call.carbon b/toolchain/parse/testdata/operators/recover_postfix_space_in_call.carbon
index eb600fcf651b..dad3743d6f97 100644
--- a/toolchain/parse/testdata/operators/recover_postfix_space_in_call.carbon
+++ b/toolchain/parse/testdata/operators/recover_postfix_space_in_call.carbon
@@ -20,7 +20,7 @@ var n: i8 = F(i8 *);
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'F'},
 // CHECK:STDOUT:         {kind: 'CallExprStart', text: '(', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'CallExpr', text: ')', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 11},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/operators/recover_postfix_space_surrounding.carbon b/toolchain/parse/testdata/operators/recover_postfix_space_surrounding.carbon
index 8ad5c4b9ec1e..cf5d6bf0744e 100644
--- a/toolchain/parse/testdata/operators/recover_postfix_space_surrounding.carbon
+++ b/toolchain/parse/testdata/operators/recover_postfix_space_surrounding.carbon
@@ -18,7 +18,7 @@ var v: type = i8 * ;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IntTypeLiteral', text: 'i8'},
-// CHECK:STDOUT:       {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/recover_prefix_repeat.carbon b/toolchain/parse/testdata/operators/recover_prefix_repeat.carbon
index e238249e4a27..17a7957e92ef 100644
--- a/toolchain/parse/testdata/operators/recover_prefix_repeat.carbon
+++ b/toolchain/parse/testdata/operators/recover_prefix_repeat.carbon
@@ -18,9 +18,9 @@ fn F() -> const const i32* {
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:                 {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:               {kind: 'PrefixOperator', text: 'const', subtree_size: 2},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: 'const', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 4},
+// CHECK:STDOUT:               {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 5},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 11},
diff --git a/toolchain/parse/testdata/operators/recover_prefix_space.carbon b/toolchain/parse/testdata/operators/recover_prefix_space.carbon
index b5623aa1b3d6..a9589fd6ce56 100644
--- a/toolchain/parse/testdata/operators/recover_prefix_space.carbon
+++ b/toolchain/parse/testdata/operators/recover_prefix_space.carbon
@@ -18,7 +18,7 @@ var n: i8 = - n;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/recover_prefix_uneven_space_with_assign.carbon b/toolchain/parse/testdata/operators/recover_prefix_uneven_space_with_assign.carbon
index fb672d6a85d0..758e4b5a5064 100644
--- a/toolchain/parse/testdata/operators/recover_prefix_uneven_space_with_assign.carbon
+++ b/toolchain/parse/testdata/operators/recover_prefix_uneven_space_with_assign.carbon
@@ -18,7 +18,7 @@ var n: i8 =- n;
 // CHECK:STDOUT:       {kind: 'BindingPattern', text: ':', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:         {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:       {kind: 'PrefixOperator', text: '-', subtree_size: 2},
+// CHECK:STDOUT:       {kind: 'PrefixOperatorMinus', text: '-', subtree_size: 2},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
 // CHECK:STDOUT:   ]
diff --git a/toolchain/parse/testdata/operators/spaceship.carbon b/toolchain/parse/testdata/operators/spaceship.carbon
index bb7f4ee5148c..00720e44657e 100644
--- a/toolchain/parse/testdata/operators/spaceship.carbon
+++ b/toolchain/parse/testdata/operators/spaceship.carbon
@@ -18,7 +18,7 @@ fn F() {
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 5},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'a'},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'b'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '<=>', subtree_size: 3},
+// CHECK:STDOUT:         {kind: 'InfixOperatorLessEqualGreater', text: '<=>', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ExprStatement', text: ';', subtree_size: 4},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 10},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/pointer/const_pointer.carbon b/toolchain/parse/testdata/pointer/const_pointer.carbon
index b64a36e60ad9..3c15a0e373ef 100644
--- a/toolchain/parse/testdata/pointer/const_pointer.carbon
+++ b/toolchain/parse/testdata/pointer/const_pointer.carbon
@@ -16,8 +16,8 @@ fn C() -> const (i32*) { return C(); }
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PrefixOperator', text: 'const', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 9},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
@@ -32,9 +32,9 @@ fn C() -> const (i32*) { return C(); }
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:                 {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:               {kind: 'PrefixOperator', text: 'const', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'ParenExpr', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 11},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
@@ -49,9 +49,9 @@ fn C() -> const (i32*) { return C(); }
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 2},
 // CHECK:STDOUT:               {kind: 'ExprOpenParen', text: '('},
 // CHECK:STDOUT:                 {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:               {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:               {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'ParenExpr', text: ')', subtree_size: 4},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: 'const', subtree_size: 5},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorConst', text: 'const', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 11},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
diff --git a/toolchain/parse/testdata/pointer/fail_pointer_type_in_expr.carbon b/toolchain/parse/testdata/pointer/fail_pointer_type_in_expr.carbon
index 098809009aeb..be85201a448b 100644
--- a/toolchain/parse/testdata/pointer/fail_pointer_type_in_expr.carbon
+++ b/toolchain/parse/testdata/pointer/fail_pointer_type_in_expr.carbon
@@ -45,10 +45,10 @@ fn H() -> i32 {
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
 // CHECK:STDOUT:               {kind: 'IntLiteral', text: '3'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'InfixOperator', text: '*', subtree_size: 3},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:             {kind: 'InfixOperatorStar', text: '*', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:           {kind: 'IntLiteral', text: '4'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '*', has_error: yes, subtree_size: 6},
+// CHECK:STDOUT:         {kind: 'InfixOperatorStar', text: '*', has_error: yes, subtree_size: 6},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 16},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
@@ -60,9 +60,9 @@ fn H() -> i32 {
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'IntLiteral', text: '4'},
-// CHECK:STDOUT:         {kind: 'InfixOperator', text: '+', has_error: yes, subtree_size: 4},
+// CHECK:STDOUT:         {kind: 'InfixOperatorPlus', text: '+', has_error: yes, subtree_size: 4},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 6},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 14},
 // CHECK:STDOUT:         {kind: 'FunctionIntroducer', text: 'fn'},
@@ -74,8 +74,8 @@ fn H() -> i32 {
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 7},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', has_error: yes, subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', has_error: yes, subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 13},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/pointer/pointer_type.carbon b/toolchain/parse/testdata/pointer/pointer_type.carbon
index 9f75693d235e..cdecc8d76aa9 100644
--- a/toolchain/parse/testdata/pointer/pointer_type.carbon
+++ b/toolchain/parse/testdata/pointer/pointer_type.carbon
@@ -18,11 +18,11 @@ var T: type = if true then i32* else f64*;
 // CHECK:STDOUT:           {kind: 'TuplePatternStart', text: '('},
 // CHECK:STDOUT:             {kind: 'IdentifierName', text: 'p'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:           {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'TuplePattern', text: ')', subtree_size: 6},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'ReturnType', text: '->', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'FunctionDefinitionStart', text: '{', subtree_size: 12},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
@@ -37,10 +37,10 @@ var T: type = if true then i32* else f64*;
 // CHECK:STDOUT:           {kind: 'BoolLiteralTrue', text: 'true'},
 // CHECK:STDOUT:         {kind: 'IfExprIf', text: 'if', subtree_size: 2},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'IfExprThen', text: 'then', subtree_size: 3},
 // CHECK:STDOUT:           {kind: 'FloatTypeLiteral', text: 'f64'},
-// CHECK:STDOUT:         {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'IfExprElse', text: 'else', subtree_size: 8},
 // CHECK:STDOUT:     {kind: 'VariableDecl', text: ';', subtree_size: 14},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},
diff --git a/toolchain/parse/testdata/pointer/pointer_value.carbon b/toolchain/parse/testdata/pointer/pointer_value.carbon
index f29d5576a958..3083f08b688d 100644
--- a/toolchain/parse/testdata/pointer/pointer_value.carbon
+++ b/toolchain/parse/testdata/pointer/pointer_value.carbon
@@ -31,26 +31,26 @@ fn F() -> i32 {
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'IdentifierName', text: 'p'},
 // CHECK:STDOUT:             {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
 // CHECK:STDOUT:         {kind: 'BindingPattern', text: ':', subtree_size: 4},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'n'},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '&', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorAmp', text: '&', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 9},
 // CHECK:STDOUT:         {kind: 'VariableIntroducer', text: 'var'},
 // CHECK:STDOUT:           {kind: 'IdentifierName', text: 'q'},
 // CHECK:STDOUT:               {kind: 'IntTypeLiteral', text: 'i32'},
-// CHECK:STDOUT:             {kind: 'PostfixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:           {kind: 'PostfixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:             {kind: 'PostfixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:           {kind: 'PostfixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:         {kind: 'BindingPattern', text: ':', subtree_size: 5},
 // CHECK:STDOUT:         {kind: 'VariableInitializer', text: '='},
 // CHECK:STDOUT:           {kind: 'IdentifierNameExpr', text: 'p'},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '&', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorAmp', text: '&', subtree_size: 2},
 // CHECK:STDOUT:       {kind: 'VariableDecl', text: ';', subtree_size: 10},
 // CHECK:STDOUT:         {kind: 'ReturnStatementStart', text: 'return'},
 // CHECK:STDOUT:             {kind: 'IdentifierNameExpr', text: 'q'},
-// CHECK:STDOUT:           {kind: 'PrefixOperator', text: '*', subtree_size: 2},
-// CHECK:STDOUT:         {kind: 'PrefixOperator', text: '*', subtree_size: 3},
+// CHECK:STDOUT:           {kind: 'PrefixOperatorStar', text: '*', subtree_size: 2},
+// CHECK:STDOUT:         {kind: 'PrefixOperatorStar', text: '*', subtree_size: 3},
 // CHECK:STDOUT:       {kind: 'ReturnStatement', text: ';', subtree_size: 5},
 // CHECK:STDOUT:     {kind: 'FunctionDefinition', text: '}', subtree_size: 39},
 // CHECK:STDOUT:     {kind: 'FileEnd', text: ''},