Support for parsing expression patterns (#6977)

When parsing a pattern, if we encounter something that isn't pattern
syntax, try parsing as an expression instead. We only need one-token
lookahead to distinguish pattern syntax from expression syntax.

Track a precedence group through pattern parsing so that we can allow
different kinds of expressions in a top-level pattern (such as the
operand of `let`) and in a nested pattern (such as a subpattern of a
tuple pattern or within grouping parens). For example, we do not allow
`case if ...`, and for now I've chosen to also not allow logical or
relational operators at the top level of a pattern, so `case 1 + 1` is
OK, but `case 1 == 1` and `case true and false` require parentheses.
This decision should be ratified or revisited by a design proposal.

Very basic check support is also provided, only sufficient to form an
`ExprPattern` instruction and nothing beyond that. For now, all pattern
matching against an `ExprPattern` fails with a TODO error. To support
that, I've switched from calling `BeginSubpattern` in the parent handler
of a pattern and `EndSubpatternAs*` in the pattern handler itself to
calling both functions in parent handlers, with `EndSubpattern`
converting an expression into an expression pattern where needed.

Depends on #6976.

Assisted-by: Gemini via Google Antigravity

toolchain/parse/handle_pattern.cpp

@@ -7,30 +7,80 @@
 
 namespace Carbon::Parse {
 
+static auto IsBindingPatternOperator(Lex::TokenKind kind) -> bool {
+  return kind == Lex::TokenKind::Colon ||
+         kind == Lex::TokenKind::ColonExclaim ||
+         kind == Lex::TokenKind::ColonQuestion;
+}
+
 auto HandlePattern(Context& context) -> void {
   auto state = context.PopState();
   switch (context.PositionKind()) {
     case Lex::TokenKind::OpenParen:
       context.PushStateForPattern(StateKind::PatternListAsTuple,
-                                  state.in_var_pattern,
-                                  state.in_unused_pattern);
+                                  state.in_var_pattern, state.in_unused_pattern,
+                                  state.ambient_precedence);
       break;
     case Lex::TokenKind::Var:
       context.PushStateForPattern(StateKind::VariablePattern,
-                                  state.in_var_pattern,
-                                  state.in_unused_pattern);
+                                  state.in_var_pattern, state.in_unused_pattern,
+                                  state.ambient_precedence);
       break;
     case Lex::TokenKind::Unused:
       context.PushStateForPattern(StateKind::UnusedPattern,
-                                  state.in_var_pattern,
-                                  state.in_unused_pattern);
+                                  state.in_var_pattern, state.in_unused_pattern,
+                                  state.ambient_precedence);
       break;
-    default:
+    case Lex::TokenKind::Template:
+    case Lex::TokenKind::Ref:
       context.PushStateForPattern(StateKind::BindingPattern,
-                                  state.in_var_pattern,
-                                  state.in_unused_pattern);
+                                  state.in_var_pattern, state.in_unused_pattern,
+                                  state.ambient_precedence);
+      break;
+    case Lex::TokenKind::Identifier:
+    case Lex::TokenKind::SelfValueIdentifier:
+    case Lex::TokenKind::Underscore: {
+      if (IsBindingPatternOperator(
+              context.PositionKind(Lookahead::NextToken))) {
+        context.PushStateForPattern(
+            StateKind::BindingPattern, state.in_var_pattern,
+            state.in_unused_pattern, state.ambient_precedence);
+        break;
+      }
+      [[fallthrough]];
+    }
+    default:
+      context.PushState(StateKind::ExprPattern);
+      context.PushStateForExpr(state.ambient_precedence);
       break;
   }
 }
 
+auto HandleExprPattern(Context& context) -> void {
+  auto state = context.PopState();
+
+  // If we parsed an expression followed by a binding operator, we most likely
+  // have a malformed attempt to introduce a binding pattern that we interpreted
+  // as an expression pattern, so diagnose that here rather than diagnosing a
+  // missing `;` at an outer level.
+  if (IsBindingPatternOperator(context.PositionKind())) {
+    if (!state.has_error) {
+      CARBON_DIAGNOSTIC(ExpectedBindingName, Error,
+                        "unexpected expression before {0} in binding pattern",
+                        Lex::TokenKind);
+      // TODO: Underline the parsed expression.
+      context.emitter().Emit(*context.position(), ExpectedBindingName,
+                             context.PositionKind());
+      state.has_error = true;
+    }
+    context.Consume();
+    // It'd be nice to skip the type expression here too, but we can't determine
+    // the end of it.
+  }
+
+  if (state.has_error) {
+    context.ReturnErrorOnState();
+  }
+}
+
 }  // namespace Carbon::Parse