Parse support for tuple patterns in var and let (#3448)

Co-authored-by: Richard Smith <[email protected]>

toolchain/check/handle_binding_pattern.cpp

@@ -150,6 +150,7 @@ auto HandleBindingPattern(Context& context, Parse::NodeId parse_node) -> bool {
 }
 
 auto HandleTemplate(Context& context, Parse::NodeId parse_node) -> bool {
+ // TODO: diagnose if this occurs in a `var` context.
  return context.TODO(parse_node, "HandleTemplate");
 }
 

toolchain/check/handle_let.cpp

@@ -11,6 +11,9 @@ namespace Carbon::Check {
 
 auto HandleLetDecl(Context& context, Parse::NodeId parse_node) -> bool {
  auto value_id = context.node_stack().PopExpr();
+ if (context.node_stack().PeekIs<Parse::NodeKind::ParamList>()) {
+ return context.TODO(parse_node, "tuple pattern in let");
+ }
  SemIR::InstId pattern_id =
  context.node_stack().Pop<Parse::NodeKind::BindingPattern>();
  context.node_stack()

toolchain/check/handle_variable.cpp

@@ -34,15 +34,23 @@ auto HandleVariableInitializer(Context& context, Parse::NodeId parse_node)
 auto HandleVariableDecl(Context& context, Parse::NodeId parse_node) -> bool {
  // Handle the optional initializer.
  auto init_id = SemIR::InstId::Invalid;
- bool has_init =
- context.parse_tree().node_kind(context.node_stack().PeekParseNode()) !=
- Parse::NodeKind::BindingPattern;
+ Parse::NodeKind next_kind =
+ context.parse_tree().node_kind(context.node_stack().PeekParseNode());
+ if (next_kind == Parse::NodeKind::ParamList) {
+ return context.TODO(parse_node, "tuple pattern in var");
+ }
+ // TODO: find a more robust way to determine if there was an initializer.
+ bool has_init = next_kind != Parse::NodeKind::BindingPattern;
  if (has_init) {
  init_id = context.node_stack().PopExpr();
  context.node_stack()
  .PopAndDiscardSoloParseNode<Parse::NodeKind::VariableInitializer>();
  }
 
+ if (context.node_stack().PeekIs<Parse::NodeKind::ParamList>()) {
+ return context.TODO(parse_node, "tuple pattern in var");
+ }
+
  // Extract the name binding.
  auto value_id = context.node_stack().Pop<Parse::NodeKind::BindingPattern>();
  if (auto bind_name = context.insts().Get(value_id).TryAs<SemIR::BindName>()) {

toolchain/diagnostics/diagnostic_kind.def

@@ -64,15 +64,13 @@ CARBON_DIAGNOSTIC_KIND(ExpectedCloseSymbol)
 CARBON_DIAGNOSTIC_KIND(ExpectedCodeBlock)
 CARBON_DIAGNOSTIC_KIND(ExpectedExpr)
 CARBON_DIAGNOSTIC_KIND(ExpectedIdentifierAfterDotOrArrow)
-CARBON_DIAGNOSTIC_KIND(ExpectedLetBindingName)
-CARBON_DIAGNOSTIC_KIND(ExpectedParamName)
+CARBON_DIAGNOSTIC_KIND(ExpectedBindingPattern)
 CARBON_DIAGNOSTIC_KIND(ExpectedParenAfter)
 CARBON_DIAGNOSTIC_KIND(ExpectedExprSemi)
 CARBON_DIAGNOSTIC_KIND(ExpectedStatementSemi)
 CARBON_DIAGNOSTIC_KIND(ExpectedStructLiteralField)
 CARBON_DIAGNOSTIC_KIND(ExpectedVarAfterReturned)
 CARBON_DIAGNOSTIC_KIND(ExpectedVariableDecl)
-CARBON_DIAGNOSTIC_KIND(ExpectedVariableName)
 CARBON_DIAGNOSTIC_KIND(OperatorRequiresParentheses)
 CARBON_DIAGNOSTIC_KIND(StatementOperatorAsSubExpr)
 CARBON_DIAGNOSTIC_KIND(UnaryOperatorRequiresParentheses)

toolchain/parse/context.cpp

@@ -166,16 +166,6 @@ auto Context::ConsumeIf(Lex::TokenKind kind) -> std::optional<Lex::TokenIndex> {
  return Consume();
 }
 
-auto Context::ConsumeIfBindingPatternKeyword(Lex::TokenKind keyword_token,
- State keyword_state,
- int subtree_start) -> void {
- if (auto token = ConsumeIf(keyword_token)) {
- PushState(Context::StateStackEntry(
- keyword_state, PrecedenceGroup::ForTopLevelExpr(),
- PrecedenceGroup::ForTopLevelExpr(), *token, subtree_start));
- }
-}
-
 auto Context::FindNextOf(std::initializer_list<Lex::TokenKind> desired_kinds)
  -> std::optional<Lex::TokenIndex> {
  auto new_position = position_;

toolchain/parse/context.h

@@ -39,14 +39,6 @@ class Context {
  // Possible return values for FindListToken.
  enum class ListTokenKind : int8_t { Comma, Close, CommaClose };
 
- // Supported kinds for HandleBindingPattern.
- enum class BindingPatternKind : int8_t {
- ImplicitParam,
- Param,
- Variable,
- Let
- };
-
  // Used for restricting ordering of `package` and `import` directives.
  enum class PackagingState : int8_t {
  FileStart,
@@ -295,11 +287,6 @@ class Context {
  // Propagates an error up the state stack, to the parent state.
  auto ReturnErrorOnState() -> void { state_stack_.back().has_error = true; }
 
- // For HandleBindingPattern, tries to consume a wrapping keyword.
- auto ConsumeIfBindingPatternKeyword(Lex::TokenKind keyword_token,
- State keyword_state, int subtree_start)
- -> void;
-
  // Emits a diagnostic for a declaration missing a semi.
  auto EmitExpectedDeclSemi(Lex::TokenKind expected_kind) -> void;
 

toolchain/parse/handle_binding_pattern.cpp

@@ -6,46 +6,28 @@
 
 namespace Carbon::Parse {
 
-// Handles BindingPatternAs(ImplicitParam|FunctionParam|Variable|Let).
-static auto HandleBindingPattern(Context& context,
- Context::BindingPatternKind pattern_kind)
- -> void {
+auto HandleBindingPattern(Context& context) -> 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);
+ if (auto token = context.ConsumeIf(Lex::TokenKind::Template)) {
+ context.PushState(Context::StateStackEntry(
+ State::BindingPatternTemplate, PrecedenceGroup::ForTopLevelExpr(),
+ PrecedenceGroup::ForTopLevelExpr(), *token, state.subtree_start));
+ }
+
+ if (auto token = context.ConsumeIf(Lex::TokenKind::Addr)) {
+ context.PushState(Context::StateStackEntry(
+ State::BindingPatternAddress, PrecedenceGroup::ForTopLevelExpr(),
+ PrecedenceGroup::ForTopLevelExpr(), *token, 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;
- }
- }
+ CARBON_DIAGNOSTIC(ExpectedBindingPattern, Error,
+ "Expected binding pattern.");
+ context.emitter().Emit(*context.position(), ExpectedBindingPattern);
  // Add a placeholder for the type.
  context.AddLeafNode(NodeKind::InvalidParse, *context.position(),
  /*has_error=*/true);
@@ -89,22 +71,6 @@ static auto HandleBindingPattern(Context& context,
  }
 }
 
-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 {

toolchain/parse/handle_let.cpp

@@ -16,7 +16,7 @@ auto HandleLet(Context& context) -> void {
  context.PushState(state);
 
  // This will start at the pattern.
- context.PushState(State::BindingPatternAsLet);
+ context.PushState(State::Pattern);
 }
 
 auto HandleLetAfterPattern(Context& context) -> void {

toolchain/parse/handle_param.cpp

@@ -16,13 +16,11 @@ static auto HandleParam(Context& context, State pattern_state,
 }
 
 auto HandleParamAsImplicit(Context& context) -> void {
- HandleParam(context, State::BindingPatternAsImplicitParam,
- State::ParamFinishAsImplicit);
+ HandleParam(context, State::BindingPattern, State::ParamFinishAsImplicit);
 }
 
 auto HandleParamAsRegular(Context& context) -> void {
- HandleParam(context, State::BindingPatternAsParam,
- State::ParamFinishAsRegular);
+ HandleParam(context, State::BindingPattern, State::ParamFinishAsRegular);
 }
 
 // Handles ParamFinishAs(Implicit|Regular).

toolchain/parse/handle_pattern.cpp

@@ -0,0 +1,18 @@
+// 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 {
+
+auto HandlePattern(Context& context) -> void {
+ context.PopAndDiscardState();
+ if (context.PositionKind() == Lex::TokenKind::OpenParen) {
+ context.PushState(State::ParamListAsRegular);
+ } else {
+ context.PushState(State::BindingPattern);
+ }
+}
+
+} // namespace Carbon::Parse

toolchain/parse/handle_var.cpp

@@ -23,7 +23,7 @@ static auto HandleVar(Context& context, State finish_state,
  context.AddLeafNode(NodeKind::ReturnedModifier, returned_token);
  }
 
- context.PushState(State::BindingPatternAsVariable);
+ context.PushState(State::Pattern);
 }
 
 auto HandleVarAsDecl(Context& context) -> void {

toolchain/parse/node_kind.def

@@ -245,6 +245,8 @@ CARBON_PARSE_NODE_KIND_BRACKET(FunctionDecl, FunctionIntroducer,
 //
 // [Generic]PatternBinding and ParamListComma may repeat with ParamListComma
 // as a separator.
+//
+// TODO: rename ParamList to TuplePattern to reflect wider usage.
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ParamListStart, 0, CARBON_TOKEN(OpenParen))
 CARBON_PARSE_NODE_KIND_CHILD_COUNT(ImplicitParamListStart, 0,
  CARBON_TOKEN(OpenSquareBracket))
@@ -285,7 +287,7 @@ CARBON_PARSE_NODE_KIND_CHILD_COUNT(Template, 1, CARBON_TOKEN(Template))
 // `let`:
 // LetIntroducer
 // _repeated_ _external_: modifier
-// _external_: BindingPattern
+// _external_: BindingPattern or ParamList
 // LetInitializer
 // _external_: expression
 // LetDecl
@@ -301,7 +303,7 @@ CARBON_PARSE_NODE_KIND_BRACKET(LetDecl, LetIntroducer,
 // VariableIntroducer
 // _repeated_ _external_: modifier
 // _optional_ ReturnedModifier
-// _external_: BindingPattern
+// _external_: BindingPattern or ParamList
 // VariableInitializer
 // _external_: expression
 // _optional_

toolchain/parse/state.def

@@ -649,7 +649,7 @@ CARBON_PARSE_STATE(Package)
 //
 // ...
 // ^
-// 1. BindingPatternAs(ImplicitParam|Param)
+// 1. BindingPattern
 // 2. ParamFinishAs(Implicit|Regular)
 CARBON_PARSE_STATE_VARIANTS2(Param, Implicit, Regular)
 
@@ -671,6 +671,8 @@ CARBON_PARSE_STATE_VARIANTS2(ParamFinish, Implicit, Regular)
 
 // Handles processing of a parameter list `[` or `(`.
 //
+// TODO: Rename this to TuplePattern to reflect wider usage.
+//
 // ( ) (variant is Regular)
 // ^
 // [ ] (variant is Implicit)
@@ -759,6 +761,17 @@ CARBON_PARSE_STATE_VARIANTS2(ParenExprParamFinish, Unknown, Tuple)
 // (state done)
 CARBON_PARSE_STATE_VARIANTS2(ParenExprFinish, Normal, Tuple)
 
+// Handles processing of a pattern.
+//
+// ( ... )
+// ^
+// 1. ParamListAsRegular
+//
+// ...
+// ^
+// 1. BindingPattern
+CARBON_PARSE_STATE(Pattern)
+
 // Handles the initial part of a binding pattern, enqueuing type expression
 // processing.
 //
@@ -791,8 +804,7 @@ CARBON_PARSE_STATE_VARIANTS2(ParenExprFinish, Normal, Tuple)
 // ???
 // ^
 // 1. BindingPatternFinishAsRegular
-CARBON_PARSE_STATE_VARIANTS4(BindingPattern, ImplicitParam, Param, Variable,
- Let)
+CARBON_PARSE_STATE(BindingPattern)
 
 // Handles `addr` in a binding pattern.
 //
@@ -1056,13 +1068,25 @@ CARBON_PARSE_STATE(BaseDecl)
 //
 // var ... (variant is not Returned)
 // ^
-// 1. BindingPatternAsVariable
+// 1. BindingPattern
+// 2. VarAfterPattern
+// 3. VarFinishAs(Decl|For)
+//
+// var (...)
+// ^
+// 1. ParamListAsRegular
 // 2. VarAfterPattern
 // 3. VarFinishAs(Decl|For)
 //
 // returned var ... (variant is Returned)
 // ^~~~~~~~~~~~
-// 1. BindingPatternAsVariable
+// 1. BindingPattern
+// 2. VarAfterPattern
+// 3. VarFinishAsDecl
+//
+// returned var ... (variant is Returned)
+// ^~~~~~~~~~~~
+// 1. ParamListAsRegular
 // 2. VarAfterPattern
 // 3. VarFinishAsDecl
 //
@@ -1102,9 +1126,15 @@ CARBON_PARSE_STATE_VARIANTS2(VarFinish, Decl, For)
 
 // Handles the start of a `let`.
 //
+// let (...)
+// ^~~
+// 1. ParamListAsRegular
+// 2. LetAfterPattern
+// 3. LetFinish
+//
 // let ...
 // ^
-// 1. BindingPatternAsLet
+// 1. BindingPattern
 // 2. LetAfterPattern
 // 3. LetFinish
 CARBON_PARSE_STATE(Let)

toolchain/parse/testdata/basics/fail_paren_match_regression.carbon

@@ -4,7 +4,7 @@
 //
 // AUTOUPDATE
 
-// CHECK:STDERR: fail_paren_match_regression.carbon:[[@LINE+6]]:5: ERROR: Expected pattern in `var` declaration.
+// CHECK:STDERR: fail_paren_match_regression.carbon:[[@LINE+6]]:5: ERROR: Expected binding pattern.
 // CHECK:STDERR: var = (foo {})
 // CHECK:STDERR: ^
 // CHECK:STDERR: fail_paren_match_regression.carbon:[[@LINE+3]]:12: ERROR: Expected `,` or `)`.

toolchain/parse/testdata/function/declaration/fail_missing_implicit_close.carbon

@@ -8,7 +8,7 @@
 // CHECK:STDERR: fail_missing_implicit_close.carbon:[[@LINE+6]]:7: ERROR: Closing symbol does not match most recent opening symbol.
 // CHECK:STDERR: fn Div[();
 // CHECK:STDERR: ^
-// CHECK:STDERR: fail_missing_implicit_close.carbon:[[@LINE+3]]:8: ERROR: Expected parameter declaration.
+// CHECK:STDERR: fail_missing_implicit_close.carbon:[[@LINE+3]]:8: ERROR: Expected binding pattern.
 // CHECK:STDERR: fn Div[();
 // CHECK:STDERR: ^
 fn Div[();

toolchain/parse/testdata/function/declaration/fail_with_identifier_as_param.carbon

@@ -4,7 +4,7 @@
 //
 // AUTOUPDATE
 
-// CHECK:STDERR: fail_with_identifier_as_param.carbon:[[@LINE+3]]:11: ERROR: Expected parameter declaration.
+// CHECK:STDERR: fail_with_identifier_as_param.carbon:[[@LINE+3]]:11: ERROR: Expected binding pattern.
 // CHECK:STDERR: fn foo(bar);
 // CHECK:STDERR: ^
 fn foo(bar);