Rename `Parse::State` to `Parse::StateKind` (#5249)

Also renames variables of that type to match. A follow-up PR will rename
`Parse::StateStackEntry` to `Parse::State`. This is more consistent with
the naming of similar enums elsewhere in the toolchain, and with the
prevailing practice of using `state` rather than e.g. `entry` as the
name of a `StateStackEntry`.

See also discussion
[here](https://discord.com/channels/655572317891461132/963846118964350976/1326280585592700990)

toolchain/parse/context.cpp

@@ -436,14 +436,14 @@ auto Context::DiagnoseExpectedDeclSemiOrDefinition(Lex::TokenKind expected_kind)
 // definitions are deferred, such as a class or interface.
 static auto ParsingInDeferredDefinitionScope(Context& context) -> bool {
   auto& stack = context.state_stack();
-  if (stack.size() < 2 || stack.back().state != State::DeclScopeLoop) {
+  if (stack.size() < 2 || stack.back().kind != StateKind::DeclScopeLoop) {
     return false;
   }
-  auto state = stack[stack.size() - 2].state;
-  return state == State::DeclDefinitionFinishAsClass ||
-         state == State::DeclDefinitionFinishAsImpl ||
-         state == State::DeclDefinitionFinishAsInterface ||
-         state == State::DeclDefinitionFinishAsNamedConstraint;
+  auto kind = stack[stack.size() - 2].kind;
+  return kind == StateKind::DeclDefinitionFinishAsClass ||
+         kind == StateKind::DeclDefinitionFinishAsImpl ||
+         kind == StateKind::DeclDefinitionFinishAsInterface ||
+         kind == StateKind::DeclDefinitionFinishAsNamedConstraint;
 }
 
 auto Context::AddFunctionDefinitionStart(Lex::TokenIndex token, bool has_error)
@@ -470,7 +470,7 @@ auto Context::AddFunctionDefinition(Lex::TokenIndex token, bool has_error)
 auto Context::PrintForStackDump(llvm::raw_ostream& output) const -> void {
   output << "Parser stack:\n";
   for (auto [i, entry] : llvm::enumerate(state_stack_)) {
-    output << "\t" << i << ".\t" << entry.state;
+    output << "\t" << i << ".\t" << entry.kind;
     PrintTokenForStackDump(output, entry.token);
   }
   output << "\tcursor\tposition_";

toolchain/parse/context.h

@@ -75,15 +75,16 @@ class Context {
   };
 
   // Used to track state on state_stack_.
+  // TODO: Rename to `State`.
   struct StateStackEntry : public Printable<StateStackEntry> {
     // Prints state information for verbose output.
     auto Print(llvm::raw_ostream& output) const -> void {
-      output << state << " @" << token << " subtree_start=" << subtree_start
+      output << kind << " @" << token << " subtree_start=" << subtree_start
              << " has_error=" << has_error;
     }
 
     // The state.
-    State state;
+    StateKind kind;
     // Set to true to indicate that an error was found, and that contextual
     // error recovery may be needed.
     bool has_error : 1 = false;
@@ -294,26 +295,26 @@ class Context {
   }
 
   // Pushes a new state with the current position for context.
-  auto PushState(State state) -> void { PushState(state, *position_); }
+  auto PushState(StateKind kind) -> void { PushState(kind, *position_); }
 
   // Pushes a new state with a specific token for context. Used when forming a
   // new subtree when the current position isn't the start of the subtree.
-  auto PushState(State state, Lex::TokenIndex token) -> void {
-    PushState({.state = state, .token = token, .subtree_start = tree_->size()});
+  auto PushState(StateKind kind, Lex::TokenIndex token) -> void {
+    PushState({.kind = kind, .token = token, .subtree_start = tree_->size()});
   }
 
   // Pushes a new expression state with specific precedence.
   auto PushStateForExpr(PrecedenceGroup ambient_precedence) -> void {
-    PushState({.state = State::Expr,
+    PushState({.kind = StateKind::Expr,
                .ambient_precedence = ambient_precedence,
                .token = *position_,
                .subtree_start = tree_->size()});
   }
 
   // Pushes a new state with detailed precedence for expression resume states.
-  auto PushStateForExprLoop(State state, PrecedenceGroup ambient_precedence,
+  auto PushStateForExprLoop(StateKind kind, PrecedenceGroup ambient_precedence,
                             PrecedenceGroup lhs_precedence) -> void {
-    PushState({.state = state,
+    PushState({.kind = kind,
                .ambient_precedence = ambient_precedence,
                .lhs_precedence = lhs_precedence,
                .token = *position_,
@@ -322,8 +323,8 @@ class Context {
 
   // Pushes a new state for handling a pattern. `in_var_pattern` indicates
   // whether that pattern is nested inside a `var` pattern.
-  auto PushStateForPattern(State state, bool in_var_pattern) -> void {
-    PushState({.state = state,
+  auto PushStateForPattern(StateKind kind, bool in_var_pattern) -> void {
+    PushState({.kind = kind,
                .in_var_pattern = in_var_pattern,
                .token = *position_,
                .subtree_start = tree_->size()});
@@ -337,9 +338,9 @@ class Context {
                  "Excessive stack size: likely infinite loop");
   }
 
-  // Pushes a constructed state onto the stack, with a different parse state.
-  auto PushState(StateStackEntry state_entry, State parse_state) -> void {
-    state_entry.state = parse_state;
+  // Pushes a constructed state onto the stack, with a different kind.
+  auto PushState(StateStackEntry state_entry, StateKind kind) -> void {
+    state_entry.kind = kind;
     PushState(state_entry);
   }
 

toolchain/parse/handle_adapt.cpp

@@ -10,9 +10,9 @@ namespace Carbon::Parse {
 // Handles processing of a complete `adapt T` declaration.
 auto HandleAdaptAfterIntroducer(Context& context) -> void {
   auto state = context.PopState();
-  state.state = State::AdaptDecl;
+  state.kind = StateKind::AdaptDecl;
   context.PushState(state);
-  context.PushState(State::Expr);
+  context.PushState(StateKind::Expr);
 }
 
 // Handles processing of a complete `adapt T` declaration.

toolchain/parse/handle_alias.cpp

@@ -14,8 +14,8 @@ namespace Carbon::Parse {
 auto HandleAlias(Context& context) -> void {
   auto state = context.PopState();
 
-  context.PushState(state, State::AliasAfterName);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, StateKind::AliasAfterName);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleAliasAfterName(Context& context) -> void {
@@ -29,8 +29,8 @@ auto HandleAliasAfterName(Context& context) -> void {
 
   if (auto equal = context.ConsumeIf(Lex::TokenKind::Equal)) {
     context.AddLeafNode(NodeKind::AliasInitializer, *equal);
-    context.PushState(state, State::AliasFinish);
-    context.PushState(State::Expr);
+    context.PushState(state, StateKind::AliasFinish);
+    context.PushState(StateKind::Expr);
   } else {
     CARBON_DIAGNOSTIC(ExpectedAliasInitializer, Error,
                       "`alias` requires a `=` for the source");

toolchain/parse/handle_array_expr.cpp

@@ -21,8 +21,8 @@ auto HandleArrayExpr(Context& context) -> void {
   } else {
     state.has_error = true;
   }
-  context.PushState(state, State::ArrayExprComma);
-  context.PushState(State::Expr);
+  context.PushState(state, StateKind::ArrayExprComma);
+  context.PushState(StateKind::Expr);
 }
 
 auto HandleArrayExprComma(Context& context) -> void {
@@ -35,8 +35,8 @@ auto HandleArrayExprComma(Context& context) -> void {
     context.emitter().Emit(*context.position(), ExpectedArrayComma);
     state.has_error = true;
   }
-  context.PushState(state, State::ArrayExprFinish);
-  context.PushState(State::Expr);
+  context.PushState(state, StateKind::ArrayExprFinish);
+  context.PushState(StateKind::Expr);
 }
 
 auto HandleArrayExprFinish(Context& context) -> void {

toolchain/parse/handle_base.cpp

@@ -24,9 +24,9 @@ auto HandleBaseAfterIntroducer(Context& context) -> void {
     return;
   }
 
-  state.state = State::BaseDecl;
+  state.kind = StateKind::BaseDecl;
   context.PushState(state);
-  context.PushState(State::Expr);
+  context.PushState(StateKind::Expr);
 }
 
 // Handles processing of a complete `base: B` declaration.

toolchain/parse/handle_binding_pattern.cpp

@@ -14,7 +14,7 @@ auto HandleBindingPattern(Context& context) -> void {
   // An `addr` pattern may wrap the binding, and becomes the parent of the
   // `BindingPattern`.
   if (auto token = context.ConsumeIf(Lex::TokenKind::Addr)) {
-    context.PushState({.state = State::BindingPatternAddr,
+    context.PushState({.kind = StateKind::BindingPatternAddr,
                        .in_var_pattern = state.in_var_pattern,
                        .token = *token,
                        .subtree_start = state.subtree_start});
@@ -56,11 +56,12 @@ auto HandleBindingPattern(Context& context) -> void {
                         *context.position(), /*has_error=*/true);
     on_error(/*expected_name=*/true);
   }
-  if (auto kind = context.PositionKind();
-      kind == Lex::TokenKind::Colon || kind == Lex::TokenKind::ColonExclaim) {
+  if (auto token_kind = context.PositionKind();
+      token_kind == Lex::TokenKind::Colon ||
+      token_kind == Lex::TokenKind::ColonExclaim) {
     // Add the wrapper node for the `template` keyword if present.
     if (template_token) {
-      if (kind != Lex::TokenKind::ColonExclaim && !state.has_error) {
+      if (token_kind != Lex::TokenKind::ColonExclaim && !state.has_error) {
         CARBON_DIAGNOSTIC(ExpectedGenericBindingPatternAfterTemplate, Error,
                           "expected `:!` binding after `template`");
         context.emitter().Emit(*template_token,
@@ -71,9 +72,9 @@ auto HandleBindingPattern(Context& context) -> void {
                       state.has_error);
     }
 
-    state.state = kind == Lex::TokenKind::Colon
-                      ? State::BindingPatternFinishAsRegular
-                      : State::BindingPatternFinishAsGeneric;
+    state.kind = token_kind == Lex::TokenKind::Colon
+                     ? StateKind::BindingPatternFinishAsRegular
+                     : StateKind::BindingPatternFinishAsGeneric;
     // Use the `:` or `:!` for the root node.
     state.token = context.Consume();
     context.PushState(state);
@@ -82,7 +83,7 @@ auto HandleBindingPattern(Context& context) -> void {
     on_error(/*expected_name=*/false);
     // Add a substitute for a type node.
     context.AddInvalidParse(*context.position());
-    context.PushState(state, State::BindingPatternFinishAsRegular);
+    context.PushState(state, StateKind::BindingPatternFinishAsRegular);
   }
 }
 

toolchain/parse/handle_brace_expr.cpp

@@ -10,32 +10,33 @@ namespace Carbon::Parse {
 
 auto HandleBraceExpr(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::BraceExprFinishAsUnknown);
+  context.PushState(state, StateKind::BraceExprFinishAsUnknown);
 
   CARBON_CHECK(context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::OpenCurlyBrace,
                                                NodeKind::Placeholder));
   if (!context.PositionIs(Lex::TokenKind::CloseCurlyBrace)) {
-    context.PushState(State::BraceExprParamAsUnknown);
+    context.PushState(StateKind::BraceExprParamAsUnknown);
   }
 }
 
 // Prints a diagnostic for brace expression syntax errors.
 static auto HandleBraceExprParamError(Context& context,
                                       Context::StateStackEntry state,
-                                      State param_finish_state) -> void {
+                                      StateKind param_finish_state_kind)
+    -> void {
   Diagnostics::IntAsSelect mode(0);
-  switch (param_finish_state) {
-    case State::BraceExprParamFinishAsType:
+  switch (param_finish_state_kind) {
+    case StateKind::BraceExprParamFinishAsType:
       mode.value = 0;
       break;
-    case State::BraceExprParamFinishAsValue:
+    case StateKind::BraceExprParamFinishAsValue:
       mode.value = 1;
       break;
-    case State::BraceExprParamFinishAsUnknown:
+    case StateKind::BraceExprParamFinishAsUnknown:
       mode.value = 2;
       break;
     default:
-      CARBON_FATAL("Unexpected state: {0}", param_finish_state);
+      CARBON_FATAL("Unexpected state: {0}", param_finish_state_kind);
   }
   CARBON_DIAGNOSTIC(
       ExpectedStructLiteralField, Error,
@@ -45,41 +46,43 @@ static auto HandleBraceExprParamError(Context& context,
   context.emitter().Emit(*context.position(), ExpectedStructLiteralField, mode);
 
   state.has_error = true;
-  context.PushState(state, param_finish_state);
+  context.PushState(state, param_finish_state_kind);
 }
 
 // Handles BraceExprParamAs(Type|Value|Unknown).
-static auto HandleBraceExprParam(Context& context, State after_designator_state,
-                                 State param_finish_state) -> void {
+static auto HandleBraceExprParam(Context& context,
+                                 StateKind after_designator_kind,
+                                 StateKind param_finish_kind) -> void {
   auto state = context.PopState();
 
   if (!context.PositionIs(Lex::TokenKind::Period)) {
-    HandleBraceExprParamError(context, state, param_finish_state);
+    HandleBraceExprParamError(context, state, param_finish_kind);
     return;
   }
 
-  context.PushState(state, after_designator_state);
-  context.PushState(State::PeriodAsStruct);
+  context.PushState(state, after_designator_kind);
+  context.PushState(StateKind::PeriodAsStruct);
 }
 
 auto HandleBraceExprParamAsType(Context& context) -> void {
-  HandleBraceExprParam(context, State::BraceExprParamAfterDesignatorAsType,
-                       State::BraceExprParamFinishAsType);
+  HandleBraceExprParam(context, StateKind::BraceExprParamAfterDesignatorAsType,
+                       StateKind::BraceExprParamFinishAsType);
 }
 
 auto HandleBraceExprParamAsValue(Context& context) -> void {
-  HandleBraceExprParam(context, State::BraceExprParamAfterDesignatorAsValue,
-                       State::BraceExprParamFinishAsValue);
+  HandleBraceExprParam(context, StateKind::BraceExprParamAfterDesignatorAsValue,
+                       StateKind::BraceExprParamFinishAsValue);
 }
 
 auto HandleBraceExprParamAsUnknown(Context& context) -> void {
-  HandleBraceExprParam(context, State::BraceExprParamAfterDesignatorAsUnknown,
-                       State::BraceExprParamFinishAsUnknown);
+  HandleBraceExprParam(context,
+                       StateKind::BraceExprParamAfterDesignatorAsUnknown,
+                       StateKind::BraceExprParamFinishAsUnknown);
 }
 
 // Handles BraceExprParamAfterDesignatorAs(Type|Value|Unknown).
 static auto HandleBraceExprParamAfterDesignator(Context& context,
-                                                State param_finish_state)
+                                                StateKind param_finish_kind)
     -> void {
   auto state = context.PopState();
 
@@ -88,7 +91,7 @@ static auto HandleBraceExprParamAfterDesignator(Context& context,
         {Lex::TokenKind::Equal, Lex::TokenKind::Colon, Lex::TokenKind::Comma});
     if (!recovery_pos ||
         context.tokens().GetKind(*recovery_pos) == Lex::TokenKind::Comma) {
-      context.PushState(state, param_finish_state);
+      context.PushState(state, param_finish_kind);
       return;
     }
     context.SkipTo(*recovery_pos);
@@ -101,57 +104,58 @@ static auto HandleBraceExprParamAfterDesignator(Context& context,
   } else if (context.PositionIs(Lex::TokenKind::Equal)) {
     is_type = false;
   } else {
-    HandleBraceExprParamError(context, state, param_finish_state);
+    HandleBraceExprParamError(context, state, param_finish_kind);
     return;
   }
 
   // If we're changing from unknown, update the related finish states.
-  if (param_finish_state == State::BraceExprParamFinishAsUnknown) {
+  if (param_finish_kind == StateKind::BraceExprParamFinishAsUnknown) {
     auto finish_state = context.PopState();
-    CARBON_CHECK(finish_state.state == State::BraceExprFinishAsUnknown);
+    CARBON_CHECK(finish_state.kind == StateKind::BraceExprFinishAsUnknown);
     if (is_type) {
-      finish_state.state = State::BraceExprFinishAsType;
-      param_finish_state = State::BraceExprParamFinishAsType;
+      finish_state.kind = StateKind::BraceExprFinishAsType;
+      param_finish_kind = StateKind::BraceExprParamFinishAsType;
     } else {
-      finish_state.state = State::BraceExprFinishAsValue;
-      param_finish_state = State::BraceExprParamFinishAsValue;
+      finish_state.kind = StateKind::BraceExprFinishAsValue;
+      param_finish_kind = StateKind::BraceExprParamFinishAsValue;
     }
     context.PushState(finish_state);
   }
 
-  auto want_param_finish_state = is_type ? State::BraceExprParamFinishAsType
-                                         : State::BraceExprParamFinishAsValue;
-  if (param_finish_state != want_param_finish_state) {
-    HandleBraceExprParamError(context, state, param_finish_state);
+  auto want_param_finish_kind = is_type
+                                    ? StateKind::BraceExprParamFinishAsType
+                                    : StateKind::BraceExprParamFinishAsValue;
+  if (param_finish_kind != want_param_finish_kind) {
+    HandleBraceExprParamError(context, state, param_finish_kind);
     return;
   }
 
   // Struct type fields and value fields use the same grammar except
   // that one has a `:` separator and the other has an `=` separator.
   state.token = context.Consume();
-  context.PushState(state, param_finish_state);
-  context.PushState(State::Expr);
+  context.PushState(state, param_finish_kind);
+  context.PushState(StateKind::Expr);
 }
 
 auto HandleBraceExprParamAfterDesignatorAsType(Context& context) -> void {
   HandleBraceExprParamAfterDesignator(context,
-                                      State::BraceExprParamFinishAsType);
+                                      StateKind::BraceExprParamFinishAsType);
 }
 
 auto HandleBraceExprParamAfterDesignatorAsValue(Context& context) -> void {
   HandleBraceExprParamAfterDesignator(context,
-                                      State::BraceExprParamFinishAsValue);
+                                      StateKind::BraceExprParamFinishAsValue);
 }
 
 auto HandleBraceExprParamAfterDesignatorAsUnknown(Context& context) -> void {
   HandleBraceExprParamAfterDesignator(context,
-                                      State::BraceExprParamFinishAsUnknown);
+                                      StateKind::BraceExprParamFinishAsUnknown);
 }
 
 // Handles BraceExprParamFinishAs(Type|Value|Unknown).
 static auto HandleBraceExprParamFinish(Context& context, NodeKind field_kind,
-                                       NodeKind comma_kind, State param_state)
-    -> void {
+                                       NodeKind comma_kind,
+                                       StateKind param_state) -> void {
   auto state = context.PopState();
 
   if (state.has_error) {
@@ -172,19 +176,19 @@ static auto HandleBraceExprParamFinish(Context& context, NodeKind field_kind,
 auto HandleBraceExprParamFinishAsType(Context& context) -> void {
   HandleBraceExprParamFinish(context, NodeKind::StructTypeLiteralField,
                              NodeKind::StructTypeLiteralComma,
-                             State::BraceExprParamAsType);
+                             StateKind::BraceExprParamAsType);
 }
 
 auto HandleBraceExprParamFinishAsValue(Context& context) -> void {
   HandleBraceExprParamFinish(context, NodeKind::StructLiteralField,
                              NodeKind::StructLiteralComma,
-                             State::BraceExprParamAsValue);
+                             StateKind::BraceExprParamAsValue);
 }
 
 auto HandleBraceExprParamFinishAsUnknown(Context& context) -> void {
   HandleBraceExprParamFinish(context, NodeKind::InvalidParse,
                              NodeKind::InvalidParse,
-                             State::BraceExprParamAsUnknown);
+                             StateKind::BraceExprParamAsUnknown);
 }
 
 // Handles BraceExprFinishAs(Type|Value|Unknown).

toolchain/parse/handle_call_expr.cpp

@@ -9,12 +9,12 @@ namespace Carbon::Parse {
 
 auto HandleCallExpr(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::CallExprFinish);
+  context.PushState(state, StateKind::CallExprFinish);
 
   context.AddNode(NodeKind::CallExprStart, context.Consume(), state.has_error);
   if (!context.PositionIs(Lex::TokenKind::CloseParen)) {
-    context.PushState(State::CallExprParamFinish);
-    context.PushState(State::Expr);
+    context.PushState(StateKind::CallExprParamFinish);
+    context.PushState(StateKind::Expr);
   }
 }
 
@@ -28,8 +28,8 @@ auto HandleCallExprParamFinish(Context& context) -> void {
   if (context.ConsumeListToken(NodeKind::CallExprComma,
                                Lex::TokenKind::CloseParen, state.has_error) ==
       Context::ListTokenKind::Comma) {
-    context.PushState(State::CallExprParamFinish);
-    context.PushState(State::Expr);
+    context.PushState(StateKind::CallExprParamFinish);
+    context.PushState(StateKind::Expr);
   }
 }
 

toolchain/parse/handle_choice.cpp

@@ -9,8 +9,8 @@ namespace Carbon::Parse {
 auto HandleChoiceIntroducer(Context& context) -> void {
   auto state = context.PopState();
 
-  context.PushState(state, State::ChoiceDefinitionStart);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, StateKind::ChoiceDefinitionStart);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleChoiceDefinitionStart(Context& context) -> void {
@@ -37,18 +37,18 @@ auto HandleChoiceDefinitionStart(Context& context) -> void {
                   state.has_error);
 
   state.has_error = false;
-  state.state = State::ChoiceDefinitionFinish;
+  state.kind = StateKind::ChoiceDefinitionFinish;
   context.PushState(state);
 
   if (!context.PositionIs(Lex::TokenKind::CloseCurlyBrace)) {
-    context.PushState(State::ChoiceAlternative);
+    context.PushState(StateKind::ChoiceAlternative);
   }
 }
 
 auto HandleChoiceAlternative(Context& context) -> void {
   auto state = context.PopState();
 
-  context.PushState(State::ChoiceAlternativeFinish);
+  context.PushState(StateKind::ChoiceAlternativeFinish);
 
   auto token = context.ConsumeIf(Lex::TokenKind::Identifier);
   if (!token) {
@@ -68,7 +68,7 @@ auto HandleChoiceAlternative(Context& context) -> void {
 
   if (context.PositionIs(Lex::TokenKind::OpenParen)) {
     context.AddLeafNode(NodeKind::IdentifierNameBeforeParams, *token);
-    context.PushState(State::PatternListAsExplicit);
+    context.PushState(StateKind::PatternListAsExplicit);
   } else {
     context.AddLeafNode(NodeKind::IdentifierNameNotBeforeParams, *token);
   }
@@ -80,7 +80,7 @@ auto HandleChoiceAlternativeFinish(Context& context) -> void {
   if (state.has_error) {
     context.ReturnErrorOnState();
     if (!context.PositionIs(Lex::TokenKind::CloseCurlyBrace)) {
-      context.PushState(State::ChoiceAlternative);
+      context.PushState(StateKind::ChoiceAlternative);
     }
     return;
   }
@@ -88,7 +88,7 @@ auto HandleChoiceAlternativeFinish(Context& context) -> void {
   if (context.ConsumeListToken(
           NodeKind::ChoiceAlternativeListComma, Lex::TokenKind::CloseCurlyBrace,
           state.has_error) == Context::ListTokenKind::Comma) {
-    context.PushState(State::ChoiceAlternative);
+    context.PushState(StateKind::ChoiceAlternative);
   }
 }
 

toolchain/parse/handle_code_block.cpp

@@ -10,10 +10,10 @@ namespace Carbon::Parse {
 auto HandleCodeBlock(Context& context) -> void {
   context.PopAndDiscardState();
 
-  context.PushState(State::CodeBlockFinish);
+  context.PushState(StateKind::CodeBlockFinish);
   if (context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::OpenCurlyBrace,
                                       NodeKind::CodeBlockStart)) {
-    context.PushState(State::StatementScopeLoop);
+    context.PushState(StateKind::StatementScopeLoop);
   } else {
     context.AddLeafNode(NodeKind::CodeBlockStart, *context.position(),
                         /*has_error=*/true);
@@ -22,7 +22,7 @@ auto HandleCodeBlock(Context& context) -> void {
     CARBON_DIAGNOSTIC(ExpectedCodeBlock, Error, "expected braced code block");
     context.emitter().Emit(*context.position(), ExpectedCodeBlock);
 
-    context.PushState(State::Statement);
+    context.PushState(StateKind::Statement);
   }
 }
 

toolchain/parse/handle_decl_definition.cpp

@@ -11,7 +11,7 @@ namespace Carbon::Parse {
 // definition.
 static auto HandleDeclOrDefinition(Context& context, NodeKind decl_kind,
                                    NodeKind definition_start_kind,
-                                   State definition_finish_state) -> void {
+                                   StateKind definition_finish_state) -> void {
   auto state = context.PopState();
 
   if (state.has_error || !context.PositionIs(Lex::TokenKind::OpenCurlyBrace)) {
@@ -22,32 +22,32 @@ static auto HandleDeclOrDefinition(Context& context, NodeKind decl_kind,
   }
 
   context.PushState(state, definition_finish_state);
-  context.PushState(State::DeclScopeLoop);
+  context.PushState(StateKind::DeclScopeLoop);
   context.AddNode(definition_start_kind, context.Consume(), state.has_error);
 }
 
 auto HandleDeclOrDefinitionAsClass(Context& context) -> void {
   HandleDeclOrDefinition(context, NodeKind::ClassDecl,
                          NodeKind::ClassDefinitionStart,
-                         State::DeclDefinitionFinishAsClass);
+                         StateKind::DeclDefinitionFinishAsClass);
 }
 
 auto HandleDeclOrDefinitionAsImpl(Context& context) -> void {
   HandleDeclOrDefinition(context, NodeKind::ImplDecl,
                          NodeKind::ImplDefinitionStart,
-                         State::DeclDefinitionFinishAsImpl);
+                         StateKind::DeclDefinitionFinishAsImpl);
 }
 
 auto HandleDeclOrDefinitionAsInterface(Context& context) -> void {
   HandleDeclOrDefinition(context, NodeKind::InterfaceDecl,
                          NodeKind::InterfaceDefinitionStart,
-                         State::DeclDefinitionFinishAsInterface);
+                         StateKind::DeclDefinitionFinishAsInterface);
 }
 
 auto HandleDeclOrDefinitionAsNamedConstraint(Context& context) -> void {
   HandleDeclOrDefinition(context, NodeKind::NamedConstraintDecl,
                          NodeKind::NamedConstraintDefinitionStart,
-                         State::DeclDefinitionFinishAsNamedConstraint);
+                         StateKind::DeclDefinitionFinishAsNamedConstraint);
 }
 
 // Handles parsing after the declaration scope of a type.

toolchain/parse/handle_decl_name_and_params.cpp

@@ -21,21 +21,21 @@ static auto HandleName(Context& context, Context::StateStackEntry state,
       context.AddNode(not_before_params_qualifier_kind,
                       context.ConsumeChecked(Lex::TokenKind::Period),
                       state.has_error);
-      context.PushState(State::DeclNameAndParams);
+      context.PushState(StateKind::DeclNameAndParams);
       break;
 
     case Lex::TokenKind::OpenSquareBracket:
       context.AddLeafNode(before_params_kind, name_token);
-      state.state = State::DeclNameAndParamsAfterImplicit;
+      state.kind = StateKind::DeclNameAndParamsAfterImplicit;
       context.PushState(state);
-      context.PushState(State::PatternListAsImplicit);
+      context.PushState(StateKind::PatternListAsImplicit);
       break;
 
     case Lex::TokenKind::OpenParen:
       context.AddLeafNode(before_params_kind, name_token);
-      state.state = State::DeclNameAndParamsAfterParams;
+      state.kind = StateKind::DeclNameAndParamsAfterParams;
       context.PushState(state);
-      context.PushState(State::PatternListAsExplicit);
+      context.PushState(StateKind::PatternListAsExplicit);
       break;
 
     default:
@@ -86,14 +86,14 @@ auto HandleDeclNameAndParams(Context& context) -> void {
 auto HandleDeclNameAndParamsAfterImplicit(Context& context) -> void {
   auto state = context.PopState();
 
-  state.state = State::DeclNameAndParamsAfterParams;
+  state.kind = StateKind::DeclNameAndParamsAfterParams;
   context.PushState(state);
 
   if (!context.PositionIs(Lex::TokenKind::OpenParen)) {
     return;
   }
 
-  context.PushState(State::PatternListAsExplicit);
+  context.PushState(StateKind::PatternListAsExplicit);
 }
 
 auto HandleDeclNameAndParamsAfterParams(Context& context) -> void {
@@ -105,7 +105,7 @@ auto HandleDeclNameAndParamsAfterParams(Context& context) -> void {
                          ? NodeKind::IdentifierNameQualifierWithParams
                          : NodeKind::KeywordNameQualifierWithParams;
     context.AddNode(node_kind, *period, state.has_error);
-    context.PushState(State::DeclNameAndParams);
+    context.PushState(StateKind::DeclNameAndParams);
   }
 }
 

toolchain/parse/handle_decl_scope_loop.cpp

@@ -33,12 +33,12 @@ static auto HandleUnrecognizedDecl(Context& context, int32_t subtree_start)
 // Replaces the introducer placeholder node, and pushes the introducer state for
 // processing.
 static auto ApplyIntroducer(Context& context, Context::StateStackEntry state,
-                            NodeKind introducer_kind, State next_state)
+                            NodeKind introducer_kind, StateKind next_state_kind)
     -> void {
   context.ReplacePlaceholderNode(state.subtree_start, introducer_kind,
                                  context.Consume());
   // Reuse state here to retain its `subtree_start`.
-  context.PushState(state, next_state);
+  context.PushState(state, next_state_kind);
 }
 
 namespace {
@@ -53,7 +53,7 @@ enum class DeclIntroducerKind : int8_t {
 struct DeclIntroducerInfo {
   DeclIntroducerKind introducer_kind;
   NodeKind node_kind;
-  State state;
+  StateKind state_kind;
 };
 }  // namespace
 
@@ -62,52 +62,55 @@ static constexpr auto DeclIntroducers = [] {
 #define CARBON_TOKEN(Name)                              \
   {.introducer_kind = DeclIntroducerKind::Unrecognized, \
    .node_kind = NodeKind::InvalidParse,                 \
-   .state = State::Invalid},
+   .state_kind = StateKind::Invalid},
 #include "toolchain/lex/token_kind.def"
   };
-  auto set = [&](Lex::TokenKind token_kind, NodeKind node_kind, State state) {
+  auto set = [&](Lex::TokenKind token_kind, NodeKind node_kind,
+                 StateKind state) {
     introducers[token_kind.AsInt()] = {
         .introducer_kind = DeclIntroducerKind::NonPackagingDecl,
         .node_kind = node_kind,
-        .state = state};
+        .state_kind = state};
   };
   auto set_packaging = [&](Lex::TokenKind token_kind, NodeKind node_kind,
-                           State state) {
+                           StateKind state) {
     introducers[token_kind.AsInt()] = {
         .introducer_kind = DeclIntroducerKind::PackagingDecl,
         .node_kind = node_kind,
-        .state = state};
+        .state_kind = state};
   };
 
   set(Lex::TokenKind::Adapt, NodeKind::AdaptIntroducer,
-      State::AdaptAfterIntroducer);
-  set(Lex::TokenKind::Alias, NodeKind::AliasIntroducer, State::Alias);
+      StateKind::AdaptAfterIntroducer);
+  set(Lex::TokenKind::Alias, NodeKind::AliasIntroducer, StateKind::Alias);
   set(Lex::TokenKind::Base, NodeKind::BaseIntroducer,
-      State::BaseAfterIntroducer);
+      StateKind::BaseAfterIntroducer);
   set(Lex::TokenKind::Choice, NodeKind::ChoiceIntroducer,
-      State::ChoiceIntroducer);
+      StateKind::ChoiceIntroducer);
   set(Lex::TokenKind::Class, NodeKind::ClassIntroducer,
-      State::TypeAfterIntroducerAsClass);
+      StateKind::TypeAfterIntroducerAsClass);
   set(Lex::TokenKind::Constraint, NodeKind::NamedConstraintIntroducer,
-      State::TypeAfterIntroducerAsNamedConstraint);
-  set(Lex::TokenKind::Export, NodeKind::ExportIntroducer, State::ExportName);
+      StateKind::TypeAfterIntroducerAsNamedConstraint);
+  set(Lex::TokenKind::Export, NodeKind::ExportIntroducer,
+      StateKind::ExportName);
   // TODO: Treat `extend` as a declaration introducer.
   set(Lex::TokenKind::Fn, NodeKind::FunctionIntroducer,
-      State::FunctionIntroducer);
+      StateKind::FunctionIntroducer);
   set(Lex::TokenKind::Impl, NodeKind::ImplIntroducer,
-      State::ImplAfterIntroducer);
+      StateKind::ImplAfterIntroducer);
   set(Lex::TokenKind::Interface, NodeKind::InterfaceIntroducer,
-      State::TypeAfterIntroducerAsInterface);
-  set(Lex::TokenKind::Namespace, NodeKind::NamespaceStart, State::Namespace);
-  set(Lex::TokenKind::Let, NodeKind::LetIntroducer, State::Let);
-  set(Lex::TokenKind::Var, NodeKind::VariableIntroducer, State::VarAsDecl);
+      StateKind::TypeAfterIntroducerAsInterface);
+  set(Lex::TokenKind::Namespace, NodeKind::NamespaceStart,
+      StateKind::Namespace);
+  set(Lex::TokenKind::Let, NodeKind::LetIntroducer, StateKind::Let);
+  set(Lex::TokenKind::Var, NodeKind::VariableIntroducer, StateKind::VarAsDecl);
 
   set_packaging(Lex::TokenKind::Package, NodeKind::PackageIntroducer,
-                State::Package);
+                StateKind::Package);
   set_packaging(Lex::TokenKind::Library, NodeKind::LibraryIntroducer,
-                State::Library);
+                StateKind::Library);
   set_packaging(Lex::TokenKind::Import, NodeKind::ImportIntroducer,
-                State::Import);
+                StateKind::Import);
   return std::to_array(introducers);
 }();
 
@@ -152,7 +155,7 @@ static auto TryHandleAsDecl(Context& context, Context::StateStackEntry state,
     }
   }
 
-  ApplyIntroducer(context, state, info.node_kind, info.state);
+  ApplyIntroducer(context, state, info.node_kind, info.state_kind);
   return true;
 }
 
@@ -266,7 +269,7 @@ auto HandleDeclScopeLoop(Context& context) -> void {
     return;
   }
 
-  context.PushState(State::Decl);
+  context.PushState(StateKind::Decl);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_expr.cpp

@@ -47,10 +47,10 @@ auto HandleExpr(Context& context) -> void {
     }
 
     if (context.PositionIs(Lex::TokenKind::If)) {
-      context.PushState(State::IfExprFinish);
-      context.PushState(State::IfExprFinishCondition);
+      context.PushState(StateKind::IfExprFinish);
+      context.PushState(StateKind::IfExprFinishCondition);
     } else {
-      context.PushStateForExprLoop(State::ExprLoopForPrefixOperator,
+      context.PushStateForExprLoop(StateKind::ExprLoopForPrefixOperator,
                                    state.ambient_precedence,
                                    *operator_precedence);
     }
@@ -58,9 +58,9 @@ auto HandleExpr(Context& context) -> void {
     context.ConsumeAndDiscard();
     context.PushStateForExpr(*operator_precedence);
   } else {
-    context.PushStateForExprLoop(State::ExprLoop, state.ambient_precedence,
+    context.PushStateForExprLoop(StateKind::ExprLoop, state.ambient_precedence,
                                  PrecedenceGroup::ForPostfixExpr());
-    context.PushState(State::ExprInPostfix);
+    context.PushState(StateKind::ExprInPostfix);
   }
 }
 
@@ -68,7 +68,7 @@ auto HandleExprInPostfix(Context& context) -> void {
   auto state = context.PopState();
 
   // Continue to the loop state.
-  state.state = State::ExprInPostfixLoop;
+  state.kind = StateKind::ExprInPostfixLoop;
 
   // Parses a primary expression, which is either a terminal portion of an
   // expression tree, such as an identifier or literal, or a parenthesized
@@ -141,17 +141,17 @@ auto HandleExprInPostfix(Context& context) -> void {
     }
     case Lex::TokenKind::OpenCurlyBrace: {
       context.PushState(state);
-      context.PushState(State::BraceExpr);
+      context.PushState(StateKind::BraceExpr);
       break;
     }
     case Lex::TokenKind::OpenParen: {
       context.PushState(state);
-      context.PushState(State::ParenExpr);
+      context.PushState(StateKind::ParenExpr);
       break;
     }
     case Lex::TokenKind::Array: {
       context.PushState(state);
-      context.PushState(State::ArrayExpr);
+      context.PushState(StateKind::ArrayExpr);
       break;
     }
     case Lex::TokenKind::Package: {
@@ -240,22 +240,22 @@ auto HandleExprInPostfixLoop(Context& context) -> void {
   switch (context.PositionKind()) {
     case Lex::TokenKind::Period: {
       context.PushState(state);
-      context.PushState(state, State::PeriodAsExpr);
+      context.PushState(state, StateKind::PeriodAsExpr);
       break;
     }
     case Lex::TokenKind::MinusGreater: {
       context.PushState(state);
-      context.PushState(state, State::ArrowExpr);
+      context.PushState(state, StateKind::ArrowExpr);
       break;
     }
     case Lex::TokenKind::OpenParen: {
       context.PushState(state);
-      context.PushState(state, State::CallExpr);
+      context.PushState(state, StateKind::CallExpr);
       break;
     }
     case Lex::TokenKind::OpenSquareBracket: {
       context.PushState(state);
-      context.PushState(state, State::IndexExpr);
+      context.PushState(state, StateKind::IndexExpr);
       break;
     }
     default: {
@@ -328,12 +328,12 @@ auto HandleExprLoop(Context& context) -> void {
       case Lex::TokenKind::And:
         context.AddNode(NodeKind::ShortCircuitOperandAnd, state.token,
                         state.has_error);
-        state.state = State::ExprLoopForShortCircuitOperatorAsAnd;
+        state.kind = StateKind::ExprLoopForShortCircuitOperatorAsAnd;
         break;
       case Lex::TokenKind::Or:
         context.AddNode(NodeKind::ShortCircuitOperandOr, state.token,
                         state.has_error);
-        state.state = State::ExprLoopForShortCircuitOperatorAsOr;
+        state.kind = StateKind::ExprLoopForShortCircuitOperatorAsOr;
         break;
 
       // `where` also needs a virtual parse tree node, and parses its right
@@ -341,12 +341,12 @@ auto HandleExprLoop(Context& context) -> void {
       // `impls` and `=`.
       case Lex::TokenKind::Where:
         context.AddNode(NodeKind::WhereOperand, state.token, state.has_error);
-        context.PushState(state, State::WhereFinish);
-        context.PushState(State::RequirementBegin);
+        context.PushState(state, StateKind::WhereFinish);
+        context.PushState(StateKind::RequirementBegin);
         return;
 
       default:
-        state.state = State::ExprLoopForInfixOperator;
+        state.kind = StateKind::ExprLoopForInfixOperator;
         break;
     }
 
@@ -379,7 +379,7 @@ static auto HandleExprLoopForOperator(Context& context,
                                       NodeKind node_kind) -> void {
   context.AddNode(node_kind, state.token, state.has_error);
   state.has_error = false;
-  context.PushState(state, State::ExprLoop);
+  context.PushState(state, StateKind::ExprLoop);
 }
 
 auto HandleExprLoopForInfixOperator(Context& context) -> void {

toolchain/parse/handle_function.cpp

@@ -9,20 +9,20 @@ namespace Carbon::Parse {
 
 auto HandleFunctionIntroducer(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::FunctionAfterParams);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, StateKind::FunctionAfterParams);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleFunctionAfterParams(Context& context) -> void {
   auto state = context.PopState();
 
   // Regardless of whether there's a return type, we'll finish the signature.
-  context.PushState(state, State::FunctionSignatureFinish);
+  context.PushState(state, StateKind::FunctionSignatureFinish);
 
   // If there is a return type, parse the expression before adding the return
   // type node.
   if (context.PositionIs(Lex::TokenKind::MinusGreater)) {
-    context.PushState(State::FunctionReturnTypeFinish);
+    context.PushState(StateKind::FunctionReturnTypeFinish);
     context.ConsumeAndDiscard();
     context.PushStateForExpr(PrecedenceGroup::ForType());
   }
@@ -47,8 +47,8 @@ auto HandleFunctionSignatureFinish(Context& context) -> void {
       context.AddFunctionDefinitionStart(context.Consume(), state.has_error);
       // Any error is recorded on the FunctionDefinitionStart.
       state.has_error = false;
-      context.PushState(state, State::FunctionDefinitionFinish);
-      context.PushState(State::StatementScopeLoop);
+      context.PushState(state, StateKind::FunctionDefinitionFinish);
+      context.PushState(StateKind::StatementScopeLoop);
       break;
     }
     case Lex::TokenKind::Equal: {

toolchain/parse/handle_if_expr.cpp

@@ -14,7 +14,7 @@ auto HandleIfExprFinishCondition(Context& context) -> void {
   context.AddNode(NodeKind::IfExprIf, state.token, state.has_error);
 
   if (context.PositionIs(Lex::TokenKind::Then)) {
-    context.PushState(State::IfExprFinishThen);
+    context.PushState(StateKind::IfExprFinishThen);
     context.ConsumeChecked(Lex::TokenKind::Then);
     context.PushStateForExpr(*PrecedenceGroup::ForLeading(Lex::TokenKind::If));
   } else {
@@ -37,7 +37,7 @@ auto HandleIfExprFinishThen(Context& context) -> void {
   context.AddNode(NodeKind::IfExprThen, state.token, state.has_error);
 
   if (context.PositionIs(Lex::TokenKind::Else)) {
-    context.PushState(State::IfExprFinishElse);
+    context.PushState(StateKind::IfExprFinishElse);
     context.ConsumeChecked(Lex::TokenKind::Else);
     context.PushStateForExpr(*PrecedenceGroup::ForLeading(Lex::TokenKind::If));
   } else {

toolchain/parse/handle_impl.cpp

@@ -11,25 +11,25 @@ static auto ExpectAsOrTypeExpression(Context& context) -> void {
   if (context.PositionIs(Lex::TokenKind::As)) {
     // as <expression> ...
     context.AddLeafNode(NodeKind::DefaultSelfImplAs, context.Consume());
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   } else {
     // <expression> as <expression>...
-    context.PushState(State::ImplBeforeAs);
+    context.PushState(StateKind::ImplBeforeAs);
     context.PushStateForExpr(PrecedenceGroup::ForImplAs());
   }
 }
 
 auto HandleImplAfterIntroducer(Context& context) -> void {
   auto state = context.PopState();
-  state.state = State::DeclOrDefinitionAsImpl;
+  state.kind = StateKind::DeclOrDefinitionAsImpl;
   context.PushState(state);
 
   if (context.PositionIs(Lex::TokenKind::Forall)) {
     // forall [<implicit parameter list>] ...
-    context.PushState(State::ImplAfterForall);
+    context.PushState(StateKind::ImplAfterForall);
     context.AddLeafNode(NodeKind::Forall, context.Consume());
     if (context.PositionIs(Lex::TokenKind::OpenSquareBracket)) {
-      context.PushState(State::PatternListAsImplicit);
+      context.PushState(StateKind::PatternListAsImplicit);
     } else {
       CARBON_DIAGNOSTIC(ImplExpectedAfterForall, Error,
                         "expected `[` after `forall` in `impl` declaration");
@@ -63,7 +63,7 @@ auto HandleImplBeforeAs(Context& context) -> void {
   auto state = context.PopState();
   if (auto as = context.ConsumeIf(Lex::TokenKind::As)) {
     context.AddNode(NodeKind::TypeImplAs, *as, state.has_error);
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   } else {
     if (!state.has_error) {
       CARBON_DIAGNOSTIC(ImplExpectedAs, Error,

toolchain/parse/handle_import_and_package.cpp

@@ -201,8 +201,8 @@ auto HandleExportName(Context& context) -> void {
 
   RestrictExportToApi(context, state);
 
-  context.PushState(state, State::ExportNameFinish);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, StateKind::ExportNameFinish);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleExportNameFinish(Context& context) -> void {

toolchain/parse/handle_index_expr.cpp

@@ -10,11 +10,11 @@ namespace Carbon::Parse {
 
 auto HandleIndexExpr(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::IndexExprFinish);
+  context.PushState(state, StateKind::IndexExprFinish);
   context.AddNode(NodeKind::IndexExprStart,
                   context.ConsumeChecked(Lex::TokenKind::OpenSquareBracket),
                   state.has_error);
-  context.PushState(State::Expr);
+  context.PushState(StateKind::Expr);
 }
 
 auto HandleIndexExprFinish(Context& context) -> void {

toolchain/parse/handle_let.cpp

@@ -11,11 +11,11 @@ auto HandleLet(Context& context) -> void {
   auto state = context.PopState();
 
   // These will start at the `let`.
-  context.PushState(state, State::LetFinish);
-  context.PushState(state, State::LetAfterPattern);
+  context.PushState(state, StateKind::LetFinish);
+  context.PushState(state, StateKind::LetAfterPattern);
 
   // This will start at the pattern.
-  context.PushState(State::Pattern);
+  context.PushState(StateKind::Pattern);
 }
 
 auto HandleLetAfterPattern(Context& context) -> void {
@@ -30,7 +30,7 @@ auto HandleLetAfterPattern(Context& context) -> void {
 
   if (auto equals = context.ConsumeIf(Lex::TokenKind::Equal)) {
     context.AddLeafNode(NodeKind::LetInitializer, *equals);
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   }
 }
 

toolchain/parse/handle_match.cpp

@@ -7,7 +7,7 @@
 
 namespace Carbon::Parse {
 
-static auto HandleStatementsBlockStart(Context& context, State finish,
+static auto HandleStatementsBlockStart(Context& context, StateKind finish,
                                        NodeKind equal_greater, NodeKind starter,
                                        NodeKind complete) -> void {
   auto state = context.PopState();
@@ -43,7 +43,7 @@ static auto HandleStatementsBlockStart(Context& context, State finish,
 
   context.AddNode(starter, context.Consume(), state.has_error);
   context.PushState(state, finish);
-  context.PushState(State::StatementScopeLoop);
+  context.PushState(StateKind::StatementScopeLoop);
 }
 
 static auto EmitUnexpectedTokenAndRecover(Context& context) -> void {
@@ -59,8 +59,8 @@ static auto EmitUnexpectedTokenAndRecover(Context& context) -> void {
 auto HandleMatchIntroducer(Context& context) -> void {
   auto state = context.PopState();
   context.AddLeafNode(NodeKind::Placeholder, *context.position());
-  context.PushState(state, State::MatchConditionFinish);
-  context.PushState(State::ParenConditionAsMatch);
+  context.PushState(state, StateKind::MatchConditionFinish);
+  context.PushState(StateKind::ParenConditionAsMatch);
   context.ConsumeAndDiscard();
 }
 
@@ -94,22 +94,22 @@ auto HandleMatchConditionFinish(Context& context) -> void {
     state.has_error = true;
   }
 
-  context.PushState(state, State::MatchStatementFinish);
-  context.PushState(State::MatchCaseLoop);
+  context.PushState(state, StateKind::MatchStatementFinish);
+  context.PushState(StateKind::MatchCaseLoop);
 }
 
 auto HandleMatchCaseLoop(Context& context) -> void {
   context.PopAndDiscardState();
 
   if (context.PositionIs(Lex::TokenKind::Case)) {
-    context.PushState(State::MatchCaseLoop);
-    context.PushState(State::MatchCaseIntroducer);
+    context.PushState(StateKind::MatchCaseLoop);
+    context.PushState(StateKind::MatchCaseIntroducer);
   } else if (context.PositionIs(Lex::TokenKind::Default)) {
-    context.PushState(State::MatchCaseLoopAfterDefault);
-    context.PushState(State::MatchDefaultIntroducer);
+    context.PushState(StateKind::MatchCaseLoopAfterDefault);
+    context.PushState(StateKind::MatchDefaultIntroducer);
   } else if (!context.PositionIs(Lex::TokenKind::CloseCurlyBrace)) {
     EmitUnexpectedTokenAndRecover(context);
-    context.PushState(State::MatchCaseLoop);
+    context.PushState(StateKind::MatchCaseLoop);
   }
 }
 
@@ -124,12 +124,12 @@ auto HandleMatchCaseLoopAfterDefault(Context& context) -> void {
     context.emitter().Emit(*context.position(), UnreachableMatchCase, kind);
 
     context.ReturnErrorOnState();
-    context.PushState(State::MatchCaseLoopAfterDefault);
+    context.PushState(StateKind::MatchCaseLoopAfterDefault);
     context.SkipPastLikelyEnd(*context.position());
     return;
   } else if (kind != Lex::TokenKind::CloseCurlyBrace) {
     EmitUnexpectedTokenAndRecover(context);
-    context.PushState(State::MatchCaseLoopAfterDefault);
+    context.PushState(StateKind::MatchCaseLoopAfterDefault);
   }
 }
 
@@ -137,8 +137,8 @@ auto HandleMatchCaseIntroducer(Context& context) -> void {
   auto state = context.PopState();
 
   context.AddLeafNode(NodeKind::MatchCaseIntroducer, context.Consume());
-  context.PushState(state, State::MatchCaseAfterPattern);
-  context.PushState(State::Pattern);
+  context.PushState(state, StateKind::MatchCaseAfterPattern);
+  context.PushState(StateKind::Pattern);
 }
 
 auto HandleMatchCaseAfterPattern(Context& context) -> void {
@@ -152,14 +152,14 @@ auto HandleMatchCaseAfterPattern(Context& context) -> void {
     return;
   }
 
-  context.PushState(state, State::MatchCaseStart);
+  context.PushState(state, StateKind::MatchCaseStart);
   if (context.PositionIs(Lex::TokenKind::If)) {
-    context.PushState(State::MatchCaseGuardFinish);
+    context.PushState(StateKind::MatchCaseGuardFinish);
     context.AddLeafNode(NodeKind::MatchCaseGuardIntroducer, context.Consume());
     auto open_paren = context.ConsumeIf(Lex::TokenKind::OpenParen);
     if (open_paren) {
       context.AddLeafNode(NodeKind::MatchCaseGuardStart, *open_paren);
-      context.PushState(State::Expr);
+      context.PushState(StateKind::Expr);
     } else {
       if (!state.has_error) {
         CARBON_DIAGNOSTIC(ExpectedMatchCaseGuardOpenParen, Error,
@@ -208,7 +208,7 @@ auto HandleMatchCaseGuardFinish(Context& context) -> void {
 }
 
 auto HandleMatchCaseStart(Context& context) -> void {
-  HandleStatementsBlockStart(context, State::MatchCaseFinish,
+  HandleStatementsBlockStart(context, StateKind::MatchCaseFinish,
                              NodeKind::MatchCaseEqualGreater,
                              NodeKind::MatchCaseStart, NodeKind::MatchCase);
 }
@@ -223,9 +223,10 @@ auto HandleMatchCaseFinish(Context& context) -> void {
 auto HandleMatchDefaultIntroducer(Context& context) -> void {
   context.AddLeafNode(NodeKind::MatchDefaultIntroducer, context.Consume());
 
-  HandleStatementsBlockStart(
-      context, State::MatchDefaultFinish, NodeKind::MatchDefaultEqualGreater,
-      NodeKind::MatchDefaultStart, NodeKind::MatchDefault);
+  HandleStatementsBlockStart(context, StateKind::MatchDefaultFinish,
+                             NodeKind::MatchDefaultEqualGreater,
+                             NodeKind::MatchDefaultStart,
+                             NodeKind::MatchDefault);
 }
 
 auto HandleMatchDefaultFinish(Context& context) -> void {

toolchain/parse/handle_namespace.cpp

@@ -9,8 +9,8 @@ namespace Carbon::Parse {
 
 auto HandleNamespace(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::NamespaceFinish);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, StateKind::NamespaceFinish);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleNamespaceFinish(Context& context) -> void {

toolchain/parse/handle_paren_condition.cpp

@@ -9,7 +9,7 @@ namespace Carbon::Parse {
 
 // Handles ParenConditionAs(If|While|Match).
 static auto HandleParenCondition(Context& context, NodeKind start_kind,
-                                 State finish_state) -> void {
+                                 StateKind finish_state_kind) -> void {
   auto state = context.PopState();
 
   std::optional<Lex::TokenIndex> open_paren =
@@ -17,7 +17,7 @@ static auto HandleParenCondition(Context& context, NodeKind start_kind,
   if (open_paren) {
     state.token = *open_paren;
   }
-  context.PushState(state, finish_state);
+  context.PushState(state, finish_state_kind);
 
   if (!open_paren && context.PositionIs(Lex::TokenKind::OpenCurlyBrace)) {
     // For an open curly, assume the condition was completely omitted.
@@ -25,23 +25,23 @@ static auto HandleParenCondition(Context& context, NodeKind start_kind,
     // a code block and just emit an invalid parse.
     context.AddInvalidParse(*context.position());
   } else {
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   }
 }
 
 auto HandleParenConditionAsIf(Context& context) -> void {
   HandleParenCondition(context, NodeKind::IfConditionStart,
-                       State::ParenConditionFinishAsIf);
+                       StateKind::ParenConditionFinishAsIf);
 }
 
 auto HandleParenConditionAsWhile(Context& context) -> void {
   HandleParenCondition(context, NodeKind::WhileConditionStart,
-                       State::ParenConditionFinishAsWhile);
+                       StateKind::ParenConditionFinishAsWhile);
 }
 
 auto HandleParenConditionAsMatch(Context& context) -> void {
   HandleParenCondition(context, NodeKind::MatchConditionStart,
-                       State::ParenConditionFinishAsMatch);
+                       StateKind::ParenConditionFinishAsMatch);
 }
 
 auto HandleParenConditionFinishAsIf(Context& context) -> void {

toolchain/parse/handle_paren_expr.cpp

@@ -15,8 +15,8 @@ auto HandleOnlyParenExpr(Context& context) -> void {
   context.AddLeafNode(NodeKind::ParenExprStart, open_paren);
 
   state.token = open_paren;
-  context.PushState(state, State::OnlyParenExprFinish);
-  context.PushState(State::Expr);
+  context.PushState(state, StateKind::OnlyParenExprFinish);
+  context.PushState(StateKind::Expr);
 }
 
 static auto FinishParenExpr(Context& context,
@@ -52,11 +52,11 @@ auto HandleParenExpr(Context& context) -> void {
                       context.ConsumeChecked(Lex::TokenKind::OpenParen));
 
   if (context.PositionIs(Lex::TokenKind::CloseParen)) {
-    context.PushState(state, State::TupleLiteralFinish);
+    context.PushState(state, StateKind::TupleLiteralFinish);
   } else {
-    context.PushState(state, State::ParenExprFinish);
-    context.PushState(State::ExprAfterOpenParenFinish);
-    context.PushState(State::Expr);
+    context.PushState(state, StateKind::ParenExprFinish);
+    context.PushState(StateKind::ExprAfterOpenParenFinish);
+    context.PushState(StateKind::Expr);
   }
 }
 
@@ -71,15 +71,15 @@ auto HandleExprAfterOpenParenFinish(Context& context) -> void {
 
   // We found a comma, so switch parent state to tuple handling.
   auto finish_state = context.PopState();
-  CARBON_CHECK(finish_state.state == State::ParenExprFinish,
-               "Unexpected parent state, found: {0}", finish_state.state);
-  context.PushState(finish_state, State::TupleLiteralFinish);
+  CARBON_CHECK(finish_state.kind == StateKind::ParenExprFinish,
+               "Unexpected parent state, found: {0}", finish_state.kind);
+  context.PushState(finish_state, StateKind::TupleLiteralFinish);
 
   // If the comma is not immediately followed by a close paren, push handlers
   // for the next tuple element.
   if (list_token_kind != Context::ListTokenKind::CommaClose) {
-    context.PushState(state, State::TupleLiteralElementFinish);
-    context.PushState(State::Expr);
+    context.PushState(state, StateKind::TupleLiteralElementFinish);
+    context.PushState(StateKind::Expr);
   }
 }
 
@@ -90,7 +90,7 @@ auto HandleTupleLiteralElementFinish(Context& context) -> void {
                                Lex::TokenKind::CloseParen, state.has_error) ==
       Context::ListTokenKind::Comma) {
     context.PushState(state);
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   }
 }
 

toolchain/parse/handle_pattern.cpp

@@ -11,14 +11,16 @@ auto HandlePattern(Context& context) -> void {
   auto state = context.PopState();
   switch (context.PositionKind()) {
     case Lex::TokenKind::OpenParen:
-      context.PushStateForPattern(State::PatternListAsTuple,
+      context.PushStateForPattern(StateKind::PatternListAsTuple,
                                   state.in_var_pattern);
       break;
     case Lex::TokenKind::Var:
-      context.PushStateForPattern(State::VariablePattern, state.in_var_pattern);
+      context.PushStateForPattern(StateKind::VariablePattern,
+                                  state.in_var_pattern);
       break;
     default:
-      context.PushStateForPattern(State::BindingPattern, state.in_var_pattern);
+      context.PushStateForPattern(StateKind::BindingPattern,
+                                  state.in_var_pattern);
       break;
   }
 }

toolchain/parse/handle_pattern_list.cpp

@@ -8,33 +8,33 @@
 namespace Carbon::Parse {
 
 // Handles PatternListElementAs(Tuple|Explicit|Implicit).
-static auto HandlePatternListElement(Context& context, State pattern_state,
-                                     State finish_state) -> void {
+static auto HandlePatternListElement(Context& context, StateKind pattern_state,
+                                     StateKind finish_state_kind) -> void {
   auto state = context.PopState();
 
-  context.PushStateForPattern(finish_state, state.in_var_pattern);
+  context.PushStateForPattern(finish_state_kind, state.in_var_pattern);
   context.PushStateForPattern(pattern_state, state.in_var_pattern);
 }
 
 auto HandlePatternListElementAsTuple(Context& context) -> void {
-  HandlePatternListElement(context, State::Pattern,
-                           State::PatternListElementFinishAsTuple);
+  HandlePatternListElement(context, StateKind::Pattern,
+                           StateKind::PatternListElementFinishAsTuple);
 }
 
 auto HandlePatternListElementAsExplicit(Context& context) -> void {
-  HandlePatternListElement(context, State::Pattern,
-                           State::PatternListElementFinishAsExplicit);
+  HandlePatternListElement(context, StateKind::Pattern,
+                           StateKind::PatternListElementFinishAsExplicit);
 }
 
 auto HandlePatternListElementAsImplicit(Context& context) -> void {
-  HandlePatternListElement(context, State::Pattern,
-                           State::PatternListElementFinishAsImplicit);
+  HandlePatternListElement(context, StateKind::Pattern,
+                           StateKind::PatternListElementFinishAsImplicit);
 }
 
 // Handles PatternListElementFinishAs(Tuple|Explicit|Implicit).
 static auto HandlePatternListElementFinish(Context& context,
                                            Lex::TokenKind close_token,
-                                           State param_state) -> void {
+                                           StateKind param_state_kind) -> void {
   auto state = context.PopState();
 
   if (state.has_error) {
@@ -44,30 +44,31 @@ static auto HandlePatternListElementFinish(Context& context,
   if (context.ConsumeListToken(NodeKind::PatternListComma, close_token,
                                state.has_error) ==
       Context::ListTokenKind::Comma) {
-    context.PushStateForPattern(param_state, state.in_var_pattern);
+    context.PushStateForPattern(param_state_kind, state.in_var_pattern);
   }
 }
 
 auto HandlePatternListElementFinishAsTuple(Context& context) -> void {
   HandlePatternListElementFinish(context, Lex::TokenKind::CloseParen,
-                                 State::PatternListElementAsTuple);
+                                 StateKind::PatternListElementAsTuple);
 }
 
 auto HandlePatternListElementFinishAsExplicit(Context& context) -> void {
   HandlePatternListElementFinish(context, Lex::TokenKind::CloseParen,
-                                 State::PatternListElementAsExplicit);
+                                 StateKind::PatternListElementAsExplicit);
 }
 
 auto HandlePatternListElementFinishAsImplicit(Context& context) -> void {
   HandlePatternListElementFinish(context, Lex::TokenKind::CloseSquareBracket,
-                                 State::PatternListElementAsImplicit);
+                                 StateKind::PatternListElementAsImplicit);
 }
 
 // Handles PatternListAs(Tuple|Explicit|Implicit).
 static auto HandlePatternList(Context& context, NodeKind node_kind,
                               Lex::TokenKind open_token_kind,
                               Lex::TokenKind close_token_kind,
-                              State param_state, State finish_state) -> void {
+                              StateKind param_state, StateKind finish_state)
+    -> void {
   auto state = context.PopState();
 
   context.PushStateForPattern(finish_state, state.in_var_pattern);
@@ -81,22 +82,23 @@ static auto HandlePatternList(Context& context, NodeKind node_kind,
 auto HandlePatternListAsTuple(Context& context) -> void {
   HandlePatternList(context, NodeKind::TuplePatternStart,
                     Lex::TokenKind::OpenParen, Lex::TokenKind::CloseParen,
-                    State::PatternListElementAsTuple,
-                    State::PatternListFinishAsTuple);
+                    StateKind::PatternListElementAsTuple,
+                    StateKind::PatternListFinishAsTuple);
 }
 
 auto HandlePatternListAsExplicit(Context& context) -> void {
   HandlePatternList(context, NodeKind::ExplicitParamListStart,
                     Lex::TokenKind::OpenParen, Lex::TokenKind::CloseParen,
-                    State::PatternListElementAsExplicit,
-                    State::PatternListFinishAsExplicit);
+                    StateKind::PatternListElementAsExplicit,
+                    StateKind::PatternListFinishAsExplicit);
 }
 
 auto HandlePatternListAsImplicit(Context& context) -> void {
-  HandlePatternList(
-      context, NodeKind::ImplicitParamListStart,
-      Lex::TokenKind::OpenSquareBracket, Lex::TokenKind::CloseSquareBracket,
-      State::PatternListElementAsImplicit, State::PatternListFinishAsImplicit);
+  HandlePatternList(context, NodeKind::ImplicitParamListStart,
+                    Lex::TokenKind::OpenSquareBracket,
+                    Lex::TokenKind::CloseSquareBracket,
+                    StateKind::PatternListElementAsImplicit,
+                    StateKind::PatternListFinishAsImplicit);
 }
 
 // Handles PatternListFinishAs(Tuple|Explicit|Implicit).

toolchain/parse/handle_period.cpp

@@ -12,7 +12,8 @@ namespace Carbon::Parse {
 // TODO: This currently only supports identifiers on the rhs, but will in the
 // future need to handle things like `object.(Interface.member)` for qualifiers.
 static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
-                                State paren_state, bool is_arrow) -> void {
+                                StateKind paren_state_kind, bool is_arrow)
+    -> void {
   auto state = context.PopState();
 
   // We're handling `.something` or `->something`.
@@ -30,11 +31,11 @@ static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
              context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::IntLiteral,
                                              NodeKind::IntLiteral)) {
     // OK, '.42'.
-  } else if (paren_state != State::Invalid &&
+  } else if (paren_state_kind != StateKind::Invalid &&
              context.PositionIs(Lex::TokenKind::OpenParen)) {
-    state.state = paren_state;
+    state.kind = paren_state_kind;
     context.PushState(state);
-    context.PushState(State::OnlyParenExpr);
+    context.PushState(StateKind::OnlyParenExpr);
     return;
   } else {
     CARBON_DIAGNOSTIC(ExpectedIdentifierAfterPeriodOrArrow, Error,
@@ -61,18 +62,19 @@ static auto HandlePeriodOrArrow(Context& context, NodeKind node_kind,
 
 auto HandlePeriodAsExpr(Context& context) -> void {
   HandlePeriodOrArrow(context, NodeKind::MemberAccessExpr,
-                      State::CompoundMemberAccess,
+                      StateKind::CompoundMemberAccess,
                       /*is_arrow=*/false);
 }
 
 auto HandlePeriodAsStruct(Context& context) -> void {
-  HandlePeriodOrArrow(context, NodeKind::StructFieldDesignator, State::Invalid,
+  HandlePeriodOrArrow(context, NodeKind::StructFieldDesignator,
+                      StateKind::Invalid,
                       /*is_arrow=*/false);
 }
 
 auto HandleArrowExpr(Context& context) -> void {
   HandlePeriodOrArrow(context, NodeKind::PointerMemberAccessExpr,
-                      State::CompoundPointerMemberAccess,
+                      StateKind::CompoundPointerMemberAccess,
                       /*is_arrow=*/true);
 }
 

toolchain/parse/handle_requirement.cpp

@@ -22,9 +22,9 @@ auto HandleRequirementBegin(Context& context) -> void {
                     /*has_error=*/false);
     context.AddNode(NodeKind::DesignatorExpr, period, /*has_error=*/false);
     state.token = context.Consume();
-    context.PushState(state, State::RequirementOperatorFinish);
+    context.PushState(state, StateKind::RequirementOperatorFinish);
   } else {
-    context.PushState(State::RequirementOperator);
+    context.PushState(StateKind::RequirementOperator);
   }
   context.PushStateForExpr(PrecedenceGroup::ForRequirements());
 }
@@ -63,7 +63,7 @@ auto HandleRequirementOperator(Context& context) -> void {
     }
   }
   state.token = context.Consume();
-  context.PushState(state, State::RequirementOperatorFinish);
+  context.PushState(state, StateKind::RequirementOperatorFinish);
   context.PushStateForExpr(PrecedenceGroup::ForRequirements());
 }
 
@@ -97,7 +97,7 @@ auto HandleRequirementOperatorFinish(Context& context) -> void {
   }
   if (auto token = context.ConsumeIf(Lex::TokenKind::And)) {
     context.AddNode(NodeKind::RequirementAnd, *token, /*has_error=*/false);
-    context.PushState(State::RequirementBegin);
+    context.PushState(StateKind::RequirementBegin);
   }
 }
 

toolchain/parse/handle_statement.cpp

@@ -12,40 +12,40 @@ auto HandleStatement(Context& context) -> void {
 
   switch (context.PositionKind()) {
     case Lex::TokenKind::Break: {
-      context.PushState(State::StatementBreakFinish);
+      context.PushState(StateKind::StatementBreakFinish);
       context.AddLeafNode(NodeKind::BreakStatementStart, context.Consume());
       break;
     }
     case Lex::TokenKind::Continue: {
-      context.PushState(State::StatementContinueFinish);
+      context.PushState(StateKind::StatementContinueFinish);
       context.AddLeafNode(NodeKind::ContinueStatementStart, context.Consume());
       break;
     }
     case Lex::TokenKind::For: {
-      context.PushState(State::StatementForFinish);
-      context.PushState(State::StatementForHeader);
+      context.PushState(StateKind::StatementForFinish);
+      context.PushState(StateKind::StatementForHeader);
       context.ConsumeAndDiscard();
       break;
     }
     case Lex::TokenKind::If: {
-      context.PushState(State::StatementIf);
+      context.PushState(StateKind::StatementIf);
       break;
     }
     case Lex::TokenKind::Return: {
-      context.PushState(State::StatementReturn);
+      context.PushState(StateKind::StatementReturn);
       break;
     }
     case Lex::TokenKind::Returned: {
       // TODO: Consider handling this as a modifier.
-      context.PushState(State::VarAsReturned);
+      context.PushState(StateKind::VarAsReturned);
       break;
     }
     case Lex::TokenKind::While: {
-      context.PushState(State::StatementWhile);
+      context.PushState(StateKind::StatementWhile);
       break;
     }
     case Lex::TokenKind::Match: {
-      context.PushState(State::MatchIntroducer);
+      context.PushState(StateKind::MatchIntroducer);
       break;
     }
 #define CARBON_PARSE_NODE_KIND(Name)
@@ -65,11 +65,11 @@ auto HandleStatement(Context& context) -> void {
     // We intentionally don't handle Package here, because `package.` can be
     // used at the start of an expression, and it's not worth disambiguating it.
     case Lex::TokenKind::Var: {
-      context.PushState(State::Decl);
+      context.PushState(StateKind::Decl);
       break;
     }
     default: {
-      context.PushState(State::ExprStatementFinish);
+      context.PushState(StateKind::ExprStatementFinish);
       context.PushStateForExpr(PrecedenceGroup::ForExprStatement());
       break;
     }
@@ -110,11 +110,11 @@ auto HandleStatementForHeader(Context& context) -> void {
   if (open_paren) {
     state.token = *open_paren;
   }
-  state.state = State::StatementForHeaderIn;
+  state.kind = StateKind::StatementForHeaderIn;
 
   if (context.PositionIs(Lex::TokenKind::Var)) {
     context.PushState(state);
-    context.PushState(State::VarAsFor);
+    context.PushState(StateKind::VarAsFor);
     context.AddLeafNode(NodeKind::VariableIntroducer, context.Consume());
   } else {
     CARBON_DIAGNOSTIC(ExpectedVariableDecl, Error,
@@ -132,8 +132,8 @@ auto HandleStatementForHeader(Context& context) -> void {
 
 auto HandleStatementForHeaderIn(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::StatementForHeaderFinish);
-  context.PushState(State::Expr);
+  context.PushState(state, StateKind::StatementForHeaderFinish);
+  context.PushState(StateKind::Expr);
 }
 
 auto HandleStatementForHeaderFinish(Context& context) -> void {
@@ -141,7 +141,7 @@ auto HandleStatementForHeaderFinish(Context& context) -> void {
 
   context.ConsumeAndAddCloseSymbol(state.token, state, NodeKind::ForHeader);
 
-  context.PushState(State::CodeBlock);
+  context.PushState(StateKind::CodeBlock);
 }
 
 auto HandleStatementForFinish(Context& context) -> void {
@@ -153,15 +153,15 @@ auto HandleStatementForFinish(Context& context) -> void {
 auto HandleStatementIf(Context& context) -> void {
   context.PopAndDiscardState();
 
-  context.PushState(State::StatementIfConditionFinish);
-  context.PushState(State::ParenConditionAsIf);
+  context.PushState(StateKind::StatementIfConditionFinish);
+  context.PushState(StateKind::ParenConditionAsIf);
   context.ConsumeAndDiscard();
 }
 
 auto HandleStatementIfConditionFinish(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::StatementIfThenBlockFinish);
-  context.PushState(State::CodeBlock);
+  context.PushState(state, StateKind::StatementIfThenBlockFinish);
+  context.PushState(StateKind::CodeBlock);
 }
 
 auto HandleStatementIfThenBlockFinish(Context& context) -> void {
@@ -169,11 +169,11 @@ auto HandleStatementIfThenBlockFinish(Context& context) -> void {
 
   if (context.ConsumeAndAddLeafNodeIf(Lex::TokenKind::Else,
                                       NodeKind::IfStatementElse)) {
-    context.PushState(state, State::StatementIfElseBlockFinish);
+    context.PushState(state, StateKind::StatementIfElseBlockFinish);
     // `else if` is permitted as a special case.
     context.PushState(context.PositionIs(Lex::TokenKind::If)
-                          ? State::StatementIf
-                          : State::CodeBlock);
+                          ? StateKind::StatementIf
+                          : StateKind::CodeBlock);
   } else {
     context.AddNode(NodeKind::IfStatement, state.token, state.has_error);
   }
@@ -186,7 +186,7 @@ auto HandleStatementIfElseBlockFinish(Context& context) -> void {
 
 auto HandleStatementReturn(Context& context) -> void {
   auto state = context.PopState();
-  context.PushState(state, State::StatementReturnFinish);
+  context.PushState(state, StateKind::StatementReturnFinish);
 
   context.AddLeafNode(NodeKind::ReturnStatementStart, context.Consume());
 
@@ -195,7 +195,7 @@ auto HandleStatementReturn(Context& context) -> void {
     context.AddLeafNode(NodeKind::ReturnVarModifier, *var_token);
   } else if (!context.PositionIs(Lex::TokenKind::Semi)) {
     // `return <expression>;`
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   } else {
     // `return;`
   }
@@ -215,23 +215,23 @@ auto HandleStatementScopeLoop(Context& context) -> void {
       context.ReturnErrorOnState();
     }
   } else {
-    context.PushState(State::Statement);
+    context.PushState(StateKind::Statement);
   }
 }
 
 auto HandleStatementWhile(Context& context) -> void {
   context.PopAndDiscardState();
 
-  context.PushState(State::StatementWhileConditionFinish);
-  context.PushState(State::ParenConditionAsWhile);
+  context.PushState(StateKind::StatementWhileConditionFinish);
+  context.PushState(StateKind::ParenConditionAsWhile);
   context.ConsumeAndDiscard();
 }
 
 auto HandleStatementWhileConditionFinish(Context& context) -> void {
   auto state = context.PopState();
 
-  context.PushState(state, State::StatementWhileBlockFinish);
-  context.PushState(State::CodeBlock);
+  context.PushState(state, StateKind::StatementWhileBlockFinish);
+  context.PushState(StateKind::CodeBlock);
 }
 
 auto HandleStatementWhileBlockFinish(Context& context) -> void {

toolchain/parse/handle_type.cpp

@@ -9,22 +9,24 @@ namespace Carbon::Parse {
 
 // Handles processing of a type declaration or definition after its introducer.
 static auto HandleTypeAfterIntroducer(Context& context,
-                                      State after_params_state) -> void {
+                                      StateKind after_params_state_kind)
+    -> void {
   auto state = context.PopState();
-  context.PushState(state, after_params_state);
-  context.PushState(State::DeclNameAndParams, state.token);
+  context.PushState(state, after_params_state_kind);
+  context.PushState(StateKind::DeclNameAndParams, state.token);
 }
 
 auto HandleTypeAfterIntroducerAsClass(Context& context) -> void {
-  HandleTypeAfterIntroducer(context, State::DeclOrDefinitionAsClass);
+  HandleTypeAfterIntroducer(context, StateKind::DeclOrDefinitionAsClass);
 }
 
 auto HandleTypeAfterIntroducerAsInterface(Context& context) -> void {
-  HandleTypeAfterIntroducer(context, State::DeclOrDefinitionAsInterface);
+  HandleTypeAfterIntroducer(context, StateKind::DeclOrDefinitionAsInterface);
 }
 
 auto HandleTypeAfterIntroducerAsNamedConstraint(Context& context) -> void {
-  HandleTypeAfterIntroducer(context, State::DeclOrDefinitionAsNamedConstraint);
+  HandleTypeAfterIntroducer(context,
+                            StateKind::DeclOrDefinitionAsNamedConstraint);
 }
 
 }  // namespace Carbon::Parse

toolchain/parse/handle_var.cpp

@@ -8,28 +8,28 @@
 namespace Carbon::Parse {
 
 // Handles VarAs(Decl|Returned).
-static auto HandleVar(Context& context, State finish_state,
+static auto HandleVar(Context& context, StateKind finish_state_kind,
                       Lex::TokenIndex returned_token = Lex::TokenIndex::None)
     -> void {
   auto state = context.PopState();
 
   // The finished variable declaration will start at the `var` or `returned`.
-  context.PushState(state, finish_state);
+  context.PushState(state, finish_state_kind);
 
   // TODO: is there a cleaner way to give VarAfterPattern access to the `var`
   // token?
   state.token = *(context.position() - 1);
-  context.PushState(state, State::VarAfterPattern);
+  context.PushState(state, StateKind::VarAfterPattern);
 
   if (returned_token.has_value()) {
     context.AddLeafNode(NodeKind::ReturnedModifier, returned_token);
   }
 
-  context.PushStateForPattern(State::Pattern, /*in_var_pattern=*/true);
+  context.PushStateForPattern(StateKind::Pattern, /*in_var_pattern=*/true);
 }
 
 auto HandleVarAsDecl(Context& context) -> void {
-  HandleVar(context, State::VarFinishAsDecl);
+  HandleVar(context, StateKind::VarFinishAsDecl);
 }
 
 auto HandleVarAsReturned(Context& context) -> void {
@@ -47,16 +47,16 @@ auto HandleVarAsReturned(Context& context) -> void {
   }
 
   context.AddLeafNode(NodeKind::VariableIntroducer, context.Consume());
-  HandleVar(context, State::VarFinishAsDecl, returned_token);
+  HandleVar(context, StateKind::VarFinishAsDecl, returned_token);
 }
 
 auto HandleVarAsFor(Context& context) -> void {
   auto state = context.PopState();
 
   // The finished variable declaration will start at the `var`.
-  context.PushState(state, State::VarFinishAsFor);
+  context.PushState(state, StateKind::VarFinishAsFor);
 
-  context.PushState(State::Pattern);
+  context.PushState(StateKind::Pattern);
 }
 
 auto HandleVarAfterPattern(Context& context) -> void {
@@ -74,7 +74,7 @@ auto HandleVarAfterPattern(Context& context) -> void {
   if (context.PositionIs(Lex::TokenKind::Equal)) {
     context.AddLeafNode(NodeKind::VariableInitializer,
                         context.ConsumeChecked(Lex::TokenKind::Equal));
-    context.PushState(State::Expr);
+    context.PushState(StateKind::Expr);
   }
 }
 
@@ -124,10 +124,10 @@ auto HandleVariablePattern(Context& context) -> void {
     context.emitter().Emit(*context.position(), NestedVar);
     state.has_error = true;
   }
-  context.PushState(State::FinishVariablePattern);
+  context.PushState(StateKind::FinishVariablePattern);
   context.ConsumeChecked(Lex::TokenKind::Var);
 
-  context.PushStateForPattern(State::Pattern, /*in_var_pattern=*/true);
+  context.PushStateForPattern(StateKind::Pattern, /*in_var_pattern=*/true);
 }
 
 auto HandleFinishVariablePattern(Context& context) -> void {

toolchain/parse/parse.cpp

@@ -28,12 +28,12 @@ auto Parse(Lex::TokenizedBuffer& tokens, Diagnostics::Consumer& consumer,
   context.AddLeafNode(NodeKind::FileStart,
                       context.ConsumeChecked(Lex::TokenKind::FileStart));
 
-  context.PushState(State::DeclScopeLoop);
+  context.PushState(StateKind::DeclScopeLoop);
 
   while (!context.state_stack().empty()) {
-    switch (context.state_stack().back().state) {
+    switch (context.state_stack().back().kind) {
 #define CARBON_PARSE_STATE(Name) \
-  case State::Name:              \
+  case StateKind::Name:          \
     Handle##Name(context);       \
     break;
 #include "toolchain/parse/state.def"

toolchain/parse/state.cpp

@@ -6,7 +6,7 @@
 
 namespace Carbon::Parse {
 
-CARBON_DEFINE_ENUM_CLASS_NAMES(State) = {
+CARBON_DEFINE_ENUM_CLASS_NAMES(StateKind) = {
 #define CARBON_PARSE_STATE(Name) CARBON_ENUM_CLASS_NAME_STRING(Name)
 #include "toolchain/parse/state.def"
 };

toolchain/parse/state.def

@@ -39,20 +39,20 @@
 #define CARBON_PARSE_STATE(Name)
 #endif
 
-// Use CARBON_PARSE_STATE_VARIANTSN(State, Variant1, Variant2, ...) to generate
-// StateAsVariant1, StateAsVariant2, ... states.
-#define CARBON_PARSE_STATE_VARIANT(State, Variant) \
-  CARBON_PARSE_STATE(State##As##Variant)
-#define CARBON_PARSE_STATE_VARIANTS2(State, Variant1, Variant2) \
-  CARBON_PARSE_STATE_VARIANT(State, Variant1)                   \
-  CARBON_PARSE_STATE_VARIANT(State, Variant2)
-#define CARBON_PARSE_STATE_VARIANTS3(State, Variant1, Variant2, Variant3) \
-  CARBON_PARSE_STATE_VARIANT(State, Variant1)                             \
-  CARBON_PARSE_STATE_VARIANTS2(State, Variant2, Variant3)
-#define CARBON_PARSE_STATE_VARIANTS4(State, Variant1, Variant2, Variant3, \
-                                     Variant4)                            \
-  CARBON_PARSE_STATE_VARIANT(State, Variant1)                             \
-  CARBON_PARSE_STATE_VARIANTS3(State, Variant2, Variant3, Variant4)
+// Use CARBON_PARSE_STATE_VARIANTSN(Kind, Variant1, Variant2, ...) to generate
+// KindAsVariant1, KindAsVariant2, ... states.
+#define CARBON_PARSE_STATE_VARIANT(Kind, Variant) \
+  CARBON_PARSE_STATE(Kind##As##Variant)
+#define CARBON_PARSE_STATE_VARIANTS2(Kind, Variant1, Variant2) \
+  CARBON_PARSE_STATE_VARIANT(Kind, Variant1)                   \
+  CARBON_PARSE_STATE_VARIANT(Kind, Variant2)
+#define CARBON_PARSE_STATE_VARIANTS3(Kind, Variant1, Variant2, Variant3) \
+  CARBON_PARSE_STATE_VARIANT(Kind, Variant1)                             \
+  CARBON_PARSE_STATE_VARIANTS2(Kind, Variant2, Variant3)
+#define CARBON_PARSE_STATE_VARIANTS4(Kind, Variant1, Variant2, Variant3, \
+                                     Variant4)                           \
+  CARBON_PARSE_STATE_VARIANT(Kind, Variant1)                             \
+  CARBON_PARSE_STATE_VARIANTS3(Kind, Variant2, Variant3, Variant4)
 
 // Used as a default for StateStackEntry initialization in some cases. Should
 // not be put on the state stack.

toolchain/parse/state.h

@@ -11,22 +11,23 @@
 
 namespace Carbon::Parse {
 
-CARBON_DEFINE_RAW_ENUM_CLASS(State, uint8_t) {
+CARBON_DEFINE_RAW_ENUM_CLASS(StateKind, uint8_t) {
 #define CARBON_PARSE_STATE(Name) CARBON_RAW_ENUM_ENUMERATOR(Name)
 #include "toolchain/parse/state.def"
 };
 
-class State : public CARBON_ENUM_BASE(State) {
+class StateKind : public CARBON_ENUM_BASE(StateKind) {
  public:
 #define CARBON_PARSE_STATE(Name) CARBON_ENUM_CONSTANT_DECL(Name)
 #include "toolchain/parse/state.def"
 };
 
-#define CARBON_PARSE_STATE(Name) CARBON_ENUM_CONSTANT_DEFINITION(State, Name)
+#define CARBON_PARSE_STATE(Name) \
+  CARBON_ENUM_CONSTANT_DEFINITION(StateKind, Name)
 #include "toolchain/parse/state.def"
 
 // We expect State to fit compactly into 8 bits.
-static_assert(sizeof(State) == 1, "State includes padding!");
+static_assert(sizeof(StateKind) == 1, "State includes padding!");
 
 }  // namespace Carbon::Parse