[reference-binding] Make InBindingState into a true type called PatternBindingState.

This cleans up the parser code a little bit around here and will make it easier
for me to add inout.

Author: gottesmm

include/swift/AST/Pattern.h

@@ -53,6 +53,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, PatternKind kind);
 /// Pattern - Base class for all patterns in Swift.
 class alignas(8) Pattern : public ASTAllocated<Pattern> {
 protected:
+  // clang-format off
   union { uint64_t OpaqueBits;
 
   SWIFT_INLINE_BITFIELD_BASE(Pattern, bitmax(NumPatternKindBits,8)+1+1,
@@ -84,6 +85,7 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
                         IsAsyncLet : 1);
 
   } Bits;
+  // clang-format on
 
   Pattern(PatternKind kind) {
     Bits.OpaqueBits = 0;

include/swift/Parse/Parser.h

@@ -19,19 +19,20 @@
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTNode.h"
-#include "swift/AST/Expr.h"
 #include "swift/AST/DiagnosticsParse.h"
+#include "swift/AST/Expr.h"
 #include "swift/AST/LayoutConstraint.h"
 #include "swift/AST/ParseRequests.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/Stmt.h"
 #include "swift/Basic/OptionSet.h"
+#include "swift/Config.h"
 #include "swift/Parse/Lexer.h"
-#include "swift/Parse/PersistentParserState.h"
-#include "swift/Parse/Token.h"
 #include "swift/Parse/ParserPosition.h"
 #include "swift/Parse/ParserResult.h"
-#include "swift/Config.h"
+#include "swift/Parse/PatternBindingState.h"
+#include "swift/Parse/PersistentParserState.h"
+#include "swift/Parse/Token.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 
 namespace llvm {
@@ -142,30 +143,7 @@ class Parser {
 
   void recordTokenHash(StringRef token);
 
-  enum {
-    /// InVarOrLetPattern has this value when not parsing a pattern.
-    IVOLP_NotInVarOrLet,
-    
-    /// InVarOrLetPattern has this value when we're in a matching pattern, but
-    /// not within a var/let pattern.  In this phase, identifiers are references
-    /// to the enclosing scopes, not a variable binding.
-    IVOLP_InMatchingPattern,
-    
-    /// InVarOrLetPattern has this value when parsing a pattern in which bound
-    /// variables are implicitly immutable, but allowed to be marked mutable by
-    /// using a 'var' pattern.  This happens in for-each loop patterns.
-    IVOLP_ImplicitlyImmutable,
-    
-    /// When InVarOrLetPattern has this value, bound variables are mutable, and
-    /// nested let/var patterns are not permitted. This happens when parsing a
-    /// 'var' decl or when parsing inside a 'var' pattern.
-    IVOLP_InVar,
-
-    /// When InVarOrLetPattern has this value, bound variables are immutable,and
-    /// nested let/var patterns are not permitted. This happens when parsing a
-    /// 'let' decl or when parsing inside a 'let' pattern.
-    IVOLP_InLet
-  } InVarOrLetPattern = IVOLP_NotInVarOrLet;
+  PatternBindingState InBindingPattern = PatternBindingState::NotInBinding;
 
   /// Whether this context has an async attribute.
   bool InPatternWithAsyncAttribute = false;
@@ -1608,10 +1586,9 @@ class Parser {
   ParserResult<Pattern>
   parseOptionalPatternTypeAnnotation(ParserResult<Pattern> P);
   ParserResult<Pattern> parseMatchingPattern(bool isExprBasic);
-  ParserResult<Pattern> parseMatchingPatternAsLetOrVar(bool isLet,
-                                                       SourceLoc VarLoc,
-                                                       bool isExprBasic);
-  
+  ParserResult<Pattern>
+  parseMatchingPatternAsBinding(PatternBindingState newState, SourceLoc VarLoc,
+                                bool isExprBasic);
 
   Pattern *createBindingFromPattern(SourceLoc loc, Identifier name,
                                     VarDecl::Introducer introducer);

include/swift/Parse/PatternBindingState.h

@@ -0,0 +1,128 @@
+//===--- PatternBindingState.h --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_PARSE_PATTERNBINDINGSTATE_H
+#define SWIFT_PARSE_PATTERNBINDINGSTATE_H
+
+#include "swift/AST/Decl.h"
+#include "swift/Parse/Token.h"
+
+namespace swift {
+
+class Token;
+
+struct PatternBindingState {
+  enum Kind {
+    /// InBindingPattern has this value when not parsing a pattern.
+    NotInBinding,
+
+    /// InBindingPattern has this value when we're in a matching pattern, but
+    /// not within a var/let pattern.  In this phase, identifiers are references
+    /// to the enclosing scopes, not a variable binding.
+    InMatchingPattern,
+
+    /// InBindingPattern has this value when parsing a pattern in which bound
+    /// variables are implicitly immutable, but allowed to be marked mutable by
+    /// using a 'var' pattern.  This happens in for-each loop patterns.
+    ImplicitlyImmutable,
+
+    /// When InBindingPattern has this value, bound variables are mutable, and
+    /// nested let/var patterns are not permitted. This happens when parsing a
+    /// 'var' decl or when parsing inside a 'var' pattern.
+    InVar,
+
+    /// When InBindingPattern has this value, bound variables are immutable,and
+    /// nested let/var patterns are not permitted. This happens when parsing a
+    /// 'let' decl or when parsing inside a 'let' pattern.
+    InLet,
+  };
+
+  Kind kind;
+
+  PatternBindingState(Kind kind) : kind(kind) {}
+
+  operator bool() const { return kind != Kind::NotInBinding; }
+
+  operator Kind() const { return kind; }
+
+  static Optional<PatternBindingState> get(StringRef str) {
+    auto kind = llvm::StringSwitch<Kind>(str)
+                    .Case("let", Kind::InLet)
+                    .Case("var", Kind::InVar)
+                    .Default(Kind::NotInBinding);
+    return PatternBindingState(kind);
+  }
+
+  /// Try to explicitly find the new pattern binding state from a token.
+  explicit PatternBindingState(Token tok) : kind(NotInBinding) {
+    switch (tok.getKind()) {
+    case tok::kw_let:
+      kind = InLet;
+      break;
+    case tok::kw_var:
+      kind = InVar;
+      break;
+    default:
+      break;
+    }
+  }
+
+  /// Explicitly initialize from a VarDecl::Introducer.
+  explicit PatternBindingState(VarDecl::Introducer introducer)
+      : kind(NotInBinding) {
+    switch (introducer) {
+    case VarDecl::Introducer::Let:
+      kind = InLet;
+      break;
+    case VarDecl::Introducer::Var:
+      kind = InVar;
+      break;
+    }
+  }
+
+  /// If there is a direct introducer associated with this pattern binding
+  /// state, return that. Return none otherwise.
+  Optional<VarDecl::Introducer> getIntroducer() const {
+    switch (kind) {
+    case Kind::NotInBinding:
+    case Kind::InMatchingPattern:
+    case Kind::ImplicitlyImmutable:
+      return None;
+    case Kind::InVar:
+      return VarDecl::Introducer::Var;
+    case Kind::InLet:
+      return VarDecl::Introducer::Let;
+    }
+  }
+
+  PatternBindingState
+  getPatternBindingStateForIntroducer(VarDecl::Introducer defaultValue) {
+    return PatternBindingState(getIntroducer().getValueOr(defaultValue));
+  }
+
+  Optional<unsigned> getSelectIndexForIntroducer() const {
+    switch (kind) {
+    case Kind::InLet:
+      return 0;
+    case Kind::InVar:
+      return 1;
+    default:
+      return None;
+    }
+  }
+
+  bool isLet() const { return kind == Kind::InLet; }
+};
+
+} // namespace swift
+
+#endif

lib/Parse/ParseDecl.cpp

@@ -7501,8 +7501,9 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
     Pattern *pattern;
     {
       // In our recursive parse, remember that we're in a var/let pattern.
-      llvm::SaveAndRestore<decltype(InVarOrLetPattern)>
-      T(InVarOrLetPattern, isLet ? IVOLP_InLet : IVOLP_InVar);
+      llvm::SaveAndRestore<decltype(InBindingPattern)> T(
+          InBindingPattern,
+          isLet ? PatternBindingState::InLet : PatternBindingState::InVar);
 
       // Track whether we are parsing an 'async let' pattern.
       const auto hasAsyncAttr = Attributes.hasAttribute<AsyncAttr>();
@@ -8189,8 +8190,8 @@ Parser::parseDeclEnumCase(ParseDeclOptions Flags,
       // "case" label.
       {
         CancellableBacktrackingScope backtrack(*this);
-        llvm::SaveAndRestore<decltype(InVarOrLetPattern)>
-        T(InVarOrLetPattern, Parser::IVOLP_InMatchingPattern);
+        llvm::SaveAndRestore<decltype(InBindingPattern)> T(
+            InBindingPattern, PatternBindingState::InMatchingPattern);
         parseMatchingPattern(/*isExprBasic*/false);
 
         // Reset async attribute in parser context.

lib/Parse/ParseExpr.cpp

@@ -47,15 +47,15 @@ ParserResult<Expr> Parser::parseExprImpl(Diag<> Message,
   // Only do this if we're parsing a pattern, to improve QoI on malformed
   // expressions followed by (e.g.) let/var decls.
   //
-  if (InVarOrLetPattern && isOnlyStartOfMatchingPattern()) {
+  if (InBindingPattern && isOnlyStartOfMatchingPattern()) {
     ParserResult<Pattern> pattern = parseMatchingPattern(/*isExprBasic*/false);
     if (pattern.hasCodeCompletion())
       return makeParserCodeCompletionResult<Expr>();
     if (pattern.isNull())
       return nullptr;
     return makeParserResult(new (Context) UnresolvedPatternExpr(pattern.get()));
   }
-  
+
   return parseExprSequence(Message, isExprBasic,
                                 /*forConditionalDirective*/false);
 }
@@ -275,7 +275,7 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
       // pattern, then an assignment doesn't make sense.  In a "if let"
       // statement the equals is the start of the condition, so don't parse it
       // as a binary operator.
-      if (InVarOrLetPattern)
+      if (InBindingPattern)
         goto done;
       SourceLoc equalsLoc = consumeToken();
       auto *assign = new (Context) AssignExpr(equalsLoc);
@@ -1634,18 +1634,19 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
     // Parse and return this as an UnresolvedPatternExpr around a binding.  This
     // will be resolved (or rejected) by sema when the overall refutable pattern
     // it transformed from an expression into a pattern.
-    if ((InVarOrLetPattern == IVOLP_ImplicitlyImmutable ||
-         InVarOrLetPattern == IVOLP_InVar ||
-         InVarOrLetPattern == IVOLP_InLet) &&
+    if ((InBindingPattern == PatternBindingState::ImplicitlyImmutable ||
+         InBindingPattern == PatternBindingState::InVar ||
+         InBindingPattern == PatternBindingState::InLet) &&
         // If we have "case let x." or "case let x(", we parse x as a normal
         // name, not a binding, because it is the start of an enum pattern or
         // call pattern.
         peekToken().isNot(tok::period, tok::period_prefix, tok::l_paren)) {
       Identifier name;
       SourceLoc loc = consumeIdentifier(name, /*diagnoseDollarPrefix=*/false);
-      auto introducer = (InVarOrLetPattern != IVOLP_InVar
-                         ? VarDecl::Introducer::Let
-                         : VarDecl::Introducer::Var);
+      // If we have an inout/let/var, set that as our introducer. otherwise
+      // default to Let.
+      auto introducer =
+          InBindingPattern.getIntroducer().getValueOr(VarDecl::Introducer::Let);
       auto pattern = createBindingFromPattern(loc, name, introducer);
       return makeParserResult(new (Context) UnresolvedPatternExpr(pattern));
     }
@@ -1799,7 +1800,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
     Result.setHasCodeCompletionAndIsError();
     if (IDECallbacks &&
         // We cannot code complete anything after var/let.
-        (!InVarOrLetPattern || InVarOrLetPattern == IVOLP_InMatchingPattern)) {
+        (!InBindingPattern ||
+         InBindingPattern == PatternBindingState::InMatchingPattern)) {
       if (InPoundIfEnvironment) {
         IDECallbacks->completePlatformCondition();
       } else {
@@ -2785,8 +2787,8 @@ ParserResult<Expr> Parser::parseExprClosure() {
   ParserStatus Status;
   // We may be parsing this closure expr in a matching pattern context.  If so,
   // reset our state to not be in a pattern for any recursive pattern parses.
-  llvm::SaveAndRestore<decltype(InVarOrLetPattern)>
-  T(InVarOrLetPattern, IVOLP_NotInVarOrLet);
+  llvm::SaveAndRestore<decltype(InBindingPattern)> T(
+      InBindingPattern, PatternBindingState::NotInBinding);
 
   // Reset async attribute in parser context.
   llvm::SaveAndRestore<bool> AsyncAttr(InPatternWithAsyncAttribute, false);