[ast] Refactor BindingPattern to take a VarDecl::Introducer directly instead of a bool to mean a let.

I am going to be adding more VarDecl::Introducers so this is a small nice
cleanup that is cut off the larger patch.

Author: gottesmm

include/swift/AST/Pattern.h

@@ -74,9 +74,9 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
     Value : 1
   );
 
-  SWIFT_INLINE_BITFIELD(BindingPattern, Pattern, 1,
-    /// True if this is a let pattern, false if a var pattern.
-    IsLet : 1
+  SWIFT_INLINE_BITFIELD(BindingPattern, Pattern, 2,
+    /// Corresponds to VarDecl::Introducer
+    Introducer : 1
   );
 
   SWIFT_INLINE_BITFIELD(AnyPattern, Pattern, 1,
@@ -701,20 +701,30 @@ class ExprPattern : public Pattern {
 class BindingPattern : public Pattern {
   SourceLoc VarLoc;
   Pattern *SubPattern;
+
 public:
-  BindingPattern(SourceLoc loc, bool isLet, Pattern *sub)
+  BindingPattern(SourceLoc loc, VarDecl::Introducer introducer, Pattern *sub)
       : Pattern(PatternKind::Binding), VarLoc(loc), SubPattern(sub) {
-    Bits.BindingPattern.IsLet = isLet;
+    setIntroducer(introducer);
+  }
+
+  VarDecl::Introducer getIntroducer() const {
+    return VarDecl::Introducer(Bits.BindingPattern.Introducer);
+  }
+
+  void setIntroducer(VarDecl::Introducer introducer) {
+    Bits.BindingPattern.Introducer = uint8_t(introducer);
   }
 
-  static BindingPattern *createImplicit(ASTContext &Ctx, bool isLet,
+  static BindingPattern *createImplicit(ASTContext &Ctx,
+                                        VarDecl::Introducer introducer,
                                         Pattern *sub) {
-    auto *VP = new (Ctx) BindingPattern(SourceLoc(), isLet, sub);
+    auto *VP = new (Ctx) BindingPattern(SourceLoc(), introducer, sub);
     VP->setImplicit();
     return VP;
   }
 
-  bool isLet() const { return Bits.BindingPattern.IsLet; }
+  bool isLet() const { return getIntroducer() == VarDecl::Introducer::Let; }
 
   SourceLoc getLoc() const { return VarLoc; }
   SourceRange getSourceRange() const {

lib/Parse/ParsePattern.cpp

@@ -1132,8 +1132,9 @@ ParserResult<Pattern> Parser::parsePattern() {
       return makeParserCodeCompletionResult<Pattern>();
     if (subPattern.isNull())
       return nullptr;
-    return makeParserResult(
-        new (Context) BindingPattern(varLoc, isLet, subPattern.get()));
+    return makeParserResult(new (Context) BindingPattern(
+        varLoc, isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var,
+        subPattern.get()));
   }
 
   default:
@@ -1341,7 +1342,9 @@ ParserResult<Pattern> Parser::parseMatchingPatternAsLetOrVar(bool isLet,
   ParserResult<Pattern> subPattern = parseMatchingPattern(isExprBasic);
   if (subPattern.isNull())
     return nullptr;
-  auto *varP = new (Context) BindingPattern(varLoc, isLet, subPattern.get());
+  auto *varP = new (Context) BindingPattern(
+      varLoc, isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var,
+      subPattern.get());
   return makeParserResult(ParserStatus(subPattern), varP);
 }
 

lib/Parse/ParseStmt.cpp

@@ -1123,8 +1123,8 @@ static void parseGuardedPattern(Parser &P, GuardedPattern &result,
                                        P.CurDeclContext);
     var->setImplicit();
     auto namePattern = new (P.Context) NamedPattern(var);
-    auto varPattern =
-        new (P.Context) BindingPattern(loc, /*isLet*/ true, namePattern);
+    auto varPattern = new (P.Context)
+        BindingPattern(loc, VarDecl::Introducer::Let, namePattern);
     varPattern->setImplicit();
     patternResult = makeParserResult(varPattern);
   }
@@ -1652,8 +1652,10 @@ Parser::parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,
     ThePattern = parseMatchingPattern(/*isExprBasic*/ true);
 
     if (ThePattern.isNonNull()) {
-      auto *P =
-          new (Context) BindingPattern(IntroducerLoc, wasLet, ThePattern.get());
+      auto *P = new (Context) BindingPattern(IntroducerLoc,
+                                             wasLet ? VarDecl::Introducer::Let
+                                                    : VarDecl::Introducer::Var,
+                                             ThePattern.get());
       ThePattern = makeParserResult(Status, P);
     }
 

lib/Sema/DerivedConformanceCodable.cpp

@@ -1650,7 +1650,8 @@ deriveBodyDecodable_enum_init(AbstractFunctionDecl *initDecl, void *) {
           C, UnresolvedDotExpr::createImplicit(C, allKeysExpr, C.Id_popFirst));
 
       auto *theKeyPattern = BindingPattern::createImplicit(
-          C, /*isLet=*/true, NamedPattern::createImplicit(C, theKeyDecl));
+          C, VarDecl::Introducer::Let,
+          NamedPattern::createImplicit(C, theKeyDecl));
 
       guardElements.emplace_back(SourceLoc(), theKeyPattern,
                                  allKeysPopFirstCallExpr);

lib/Sema/DerivedConformances.cpp

@@ -854,8 +854,8 @@ Pattern *DerivedConformance::enumElementPayloadSubpattern(
 
       auto namedPattern = new (C) NamedPattern(payloadVar);
       namedPattern->setImplicit();
-      auto letPattern =
-          BindingPattern::createImplicit(C, /*isLet*/ true, namedPattern);
+      auto letPattern = BindingPattern::createImplicit(
+          C, VarDecl::Introducer::Let, namedPattern);
       elementPatterns.push_back(TuplePatternElt(tupleElement.getName(),
                                                 SourceLoc(), letPattern));
     }
@@ -874,8 +874,8 @@ Pattern *DerivedConformance::enumElementPayloadSubpattern(
 
   auto namedPattern = new (C) NamedPattern(payloadVar);
   namedPattern->setImplicit();
-  auto letPattern =
-      new (C) BindingPattern(SourceLoc(), /*isLet*/ true, namedPattern);
+  auto letPattern = new (C)
+      BindingPattern(SourceLoc(), VarDecl::Introducer::Let, namedPattern);
   return ParenPattern::createImplicit(C, letPattern);
 }
 

lib/Sema/TypeCheckStorage.cpp

@@ -1436,7 +1436,8 @@ synthesizeLazyGetterBody(AccessorDecl *Get, VarDecl *VD, VarDecl *Storage,
 
   auto *Named = NamedPattern::createImplicit(Ctx, Tmp1VD);
   Named->setType(Tmp1VD->getType());
-  auto *Let = BindingPattern::createImplicit(Ctx, /*let*/ true, Named);
+  auto *Let =
+      BindingPattern::createImplicit(Ctx, VarDecl::Introducer::Let, Named);
   Let->setType(Named->getType());
   auto *Some = OptionalSomePattern::createImplicit(Ctx, Let);
   Some->setType(OptionalType::get(Let->getType()));

lib/Serialization/Deserialization.cpp

@@ -415,8 +415,10 @@ Expected<Pattern *> ModuleFile::readPattern(DeclContext *owningDC) {
 
     Pattern *subPattern = readPatternUnchecked(owningDC);
 
-    auto result =
-        BindingPattern::createImplicit(getContext(), isLet, subPattern);
+    auto result = BindingPattern::createImplicit(
+        getContext(),
+        isLet ? VarDecl::Introducer::Let : VarDecl::Introducer::Var,
+        subPattern);
     if (Type interfaceType = subPattern->getDelayedInterfaceType())
       result->setDelayedInterfaceType(interfaceType, owningDC);
     else