Binding pattern naming cleanup (#3410)

- Rename `PatternBinding` to `BindingPattern`.
- Use `BindingPattern` rather than `Pattern` in the names of
binding-pattern-specific parse states.

toolchain/parse/handle_binding_pattern.cpp

@@ -0,0 +1,154 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "toolchain/parse/context.h"
+
+namespace Carbon::Parse {
+
+// Handles BindingPatternAs(ImplicitParam|FunctionParam|Variable|Let).
+static auto HandleBindingPattern(Context& context,
+                                 Context::BindingPatternKind pattern_kind)
+    -> void {
+  auto state = context.PopState();
+
+  // Parameters may have keywords prefixing the pattern. They become the parent
+  // for the full BindingPattern.
+  if (pattern_kind != Context::BindingPatternKind::Variable) {
+    context.ConsumeIfBindingPatternKeyword(Lex::TokenKind::Template,
+                                           State::BindingPatternTemplate,
+                                           state.subtree_start);
+    context.ConsumeIfBindingPatternKeyword(Lex::TokenKind::Addr,
+                                           State::BindingPatternAddress,
+                                           state.subtree_start);
+  }
+
+  // Handle an invalid pattern introducer for parameters and variables.
+  auto on_error = [&]() {
+    switch (pattern_kind) {
+      case Context::BindingPatternKind::ImplicitParam:
+      case Context::BindingPatternKind::Param: {
+        CARBON_DIAGNOSTIC(ExpectedParamName, Error,
+                          "Expected parameter declaration.");
+        context.emitter().Emit(*context.position(), ExpectedParamName);
+        break;
+      }
+      case Context::BindingPatternKind::Variable: {
+        CARBON_DIAGNOSTIC(ExpectedVariableName, Error,
+                          "Expected pattern in `var` declaration.");
+        context.emitter().Emit(*context.position(), ExpectedVariableName);
+        break;
+      }
+      case Context::BindingPatternKind::Let: {
+        CARBON_DIAGNOSTIC(ExpectedLetBindingName, Error,
+                          "Expected pattern in `let` declaration.");
+        context.emitter().Emit(*context.position(), ExpectedLetBindingName);
+        break;
+      }
+    }
+    // Add a placeholder for the type.
+    context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
+                        /*has_error=*/true);
+    state.state = State::BindingPatternFinishAsRegular;
+    state.has_error = true;
+    context.PushState(state);
+  };
+
+  // The first item should be an identifier or `self`.
+  bool has_name = false;
+  if (auto identifier = context.ConsumeIf(Lex::TokenKind::Identifier)) {
+    context.AddLeafNode(NodeKind::Name, *identifier);
+    has_name = true;
+  } else if (auto self =
+                 context.ConsumeIf(Lex::TokenKind::SelfValueIdentifier)) {
+    // Checking will validate the `self` is only declared in the implicit
+    // parameter list of a function.
+    context.AddLeafNode(NodeKind::SelfValueName, *self);
+    has_name = true;
+  }
+  if (!has_name) {
+    // Add a placeholder for the name.
+    context.AddLeafNode(NodeKind::Name, *context.position(),
+                        /*has_error=*/true);
+    on_error();
+    return;
+  }
+
+  if (auto kind = context.PositionKind();
+      kind == Lex::TokenKind::Colon || kind == Lex::TokenKind::ColonExclaim) {
+    state.state = kind == Lex::TokenKind::Colon
+                      ? State::BindingPatternFinishAsRegular
+                      : State::BindingPatternFinishAsGeneric;
+    // Use the `:` or `:!` for the root node.
+    state.token = context.Consume();
+    context.PushState(state);
+    context.PushStateForExpr(PrecedenceGroup::ForType());
+  } else {
+    on_error();
+    return;
+  }
+}
+
+auto HandleBindingPatternAsImplicitParam(Context& context) -> void {
+  HandleBindingPattern(context, Context::BindingPatternKind::ImplicitParam);
+}
+
+auto HandleBindingPatternAsParam(Context& context) -> void {
+  HandleBindingPattern(context, Context::BindingPatternKind::Param);
+}
+
+auto HandleBindingPatternAsVariable(Context& context) -> void {
+  HandleBindingPattern(context, Context::BindingPatternKind::Variable);
+}
+
+auto HandleBindingPatternAsLet(Context& context) -> void {
+  HandleBindingPattern(context, Context::BindingPatternKind::Let);
+}
+
+// Handles BindingPatternFinishAs(Generic|Regular).
+static auto HandleBindingPatternFinish(Context& context, NodeKind node_kind)
+    -> void {
+  auto state = context.PopState();
+
+  context.AddNode(node_kind, state.token, state.subtree_start, state.has_error);
+
+  // Propagate errors to the parent state so that they can take different
+  // actions on invalid patterns.
+  if (state.has_error) {
+    context.ReturnErrorOnState();
+  }
+}
+
+auto HandleBindingPatternFinishAsGeneric(Context& context) -> void {
+  HandleBindingPatternFinish(context, NodeKind::GenericBindingPattern);
+}
+
+auto HandleBindingPatternFinishAsRegular(Context& context) -> void {
+  HandleBindingPatternFinish(context, NodeKind::BindingPattern);
+}
+
+auto HandleBindingPatternAddress(Context& context) -> void {
+  auto state = context.PopState();
+
+  context.AddNode(NodeKind::Address, state.token, state.subtree_start,
+                  state.has_error);
+
+  // If an error was encountered, propagate it while adding a node.
+  if (state.has_error) {
+    context.ReturnErrorOnState();
+  }
+}
+
+auto HandleBindingPatternTemplate(Context& context) -> void {
+  auto state = context.PopState();
+
+  context.AddNode(NodeKind::Template, state.token, state.subtree_start,
+                  state.has_error);
+
+  // If an error was encountered, propagate it while adding a node.
+  if (state.has_error) {
+    context.ReturnErrorOnState();
+  }
+}
+
+}  // namespace Carbon::Parse