[reference-binding] Add support for inout binding parsing/serialization.

Author: gottesmm

include/swift/AST/Decl.h

@@ -388,9 +388,9 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     IsStatic : 1
   );
 
-  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(VarDecl, AbstractStorageDecl, 2+1+1+1+1+1,
     /// Encodes whether this is a 'let' binding.
-    Introducer : 1,
+    Introducer : 2,
 
     /// Whether this declaration captures the 'self' param under the same name.
     IsSelfParamCapture : 1,
@@ -5498,7 +5498,8 @@ class VarDecl : public AbstractStorageDecl {
 public:
   enum class Introducer : uint8_t {
     Let = 0,
-    Var = 1
+    Var = 1,
+    InOut = 2,
   };
 
 protected:

include/swift/AST/DiagnosticsParse.def

@@ -964,8 +964,8 @@ ERROR(no_default_arg_closure,none,
 ERROR(no_default_arg_curried,none,
       "default arguments are not allowed in curried parameter lists", ())
 ERROR(var_pattern_in_var,none,
-      "'%select{var|let}0' cannot appear nested inside another 'var' or "
-      "'let' pattern", (unsigned))
+      "'%select{let|inout|var}0' cannot appear nested inside another 'var', "
+      "'let', or 'inout' pattern", (unsigned))
 ERROR(extra_var_in_multiple_pattern_list,none,
       "%0 must be bound in every pattern", (Identifier))
 ERROR(let_pattern_in_immutable_context,none,

include/swift/AST/Pattern.h

@@ -77,7 +77,7 @@ class alignas(8) Pattern : public ASTAllocated<Pattern> {
 
   SWIFT_INLINE_BITFIELD(BindingPattern, Pattern, 2,
     /// Corresponds to VarDecl::Introducer
-    Introducer : 1
+    Introducer : 2
   );
 
   SWIFT_INLINE_BITFIELD(AnyPattern, Pattern, 1,
@@ -728,6 +728,17 @@ class BindingPattern : public Pattern {
 
   bool isLet() const { return getIntroducer() == VarDecl::Introducer::Let; }
 
+  StringRef getIntroducerStringRef() const {
+    switch (getIntroducer()) {
+    case VarDecl::Introducer::Let:
+      return "let";
+    case VarDecl::Introducer::Var:
+      return "var";
+    case VarDecl::Introducer::InOut:
+      return "inout";
+    }
+  }
+
   SourceLoc getLoc() const { return VarLoc; }
   SourceRange getSourceRange() const {
     SourceLoc EndLoc = SubPattern->getSourceRange().End;

include/swift/Parse/PatternBindingState.h

@@ -44,6 +44,11 @@ struct PatternBindingState {
     /// nested let/var patterns are not permitted. This happens when parsing a
     /// 'let' decl or when parsing inside a 'let' pattern.
     InLet,
+
+    /// When InBindingPattern has this value, bound variables are mutable, and
+    /// nested let/var/inout patterns are not permitted. This happens when
+    /// parsing an 'inout' decl or when parsing inside an 'inout' pattern.
+    InInOut,
   };
 
   Kind kind;
@@ -58,6 +63,7 @@ struct PatternBindingState {
     auto kind = llvm::StringSwitch<Kind>(str)
                     .Case("let", Kind::InLet)
                     .Case("var", Kind::InVar)
+                    .Case("inout", Kind::InInOut)
                     .Default(Kind::NotInBinding);
     return PatternBindingState(kind);
   }
@@ -71,6 +77,9 @@ struct PatternBindingState {
     case tok::kw_var:
       kind = InVar;
       break;
+    case tok::kw_inout:
+      kind = InInOut;
+      break;
     default:
       break;
     }
@@ -86,6 +95,9 @@ struct PatternBindingState {
     case VarDecl::Introducer::Var:
       kind = InVar;
       break;
+    case VarDecl::Introducer::InOut:
+      kind = InInOut;
+      break;
     }
   }
 
@@ -101,6 +113,8 @@ struct PatternBindingState {
       return VarDecl::Introducer::Var;
     case Kind::InLet:
       return VarDecl::Introducer::Let;
+    case Kind::InInOut:
+      return VarDecl::Introducer::InOut;
     }
   }
 
@@ -113,8 +127,10 @@ struct PatternBindingState {
     switch (kind) {
     case Kind::InLet:
       return 0;
-    case Kind::InVar:
+    case Kind::InInOut:
       return 1;
+    case Kind::InVar:
+      return 2;
     default:
       return None;
     }

lib/Parse/ParseDecl.cpp

@@ -4678,6 +4678,7 @@ bool swift::isKeywordPossibleDeclStart(const Token &Tok) {
   case tok::kw_func:
   case tok::kw_import:
   case tok::kw_init:
+  case tok::kw_inout:
   case tok::kw_internal:
   case tok::kw_let:
   case tok::kw_operator:
@@ -5067,11 +5068,11 @@ Parser::parseDecl(ParseDeclOptions Flags,
 
   bool HandlerAlreadyCalled = false;
 
-  auto parseLetOrVar = [&](bool HasLetOrVarKeyword) {
+  auto parseBindingIntroducer = [&](bool HasBindingIntroducerKeyword) {
     // Collect all modifiers into a modifier list.
     llvm::SmallVector<Decl *, 4> Entries;
     DeclResult = parseDeclVar(Flags, Attributes, Entries, StaticLoc,
-                              StaticSpelling, tryLoc, HasLetOrVarKeyword);
+                              StaticSpelling, tryLoc, HasBindingIntroducerKeyword);
     StaticLoc = SourceLoc(); // we handled static if present.
     MayNeedOverrideCompletion = true;
     if ((AttrStatus.hasCodeCompletion() || DeclResult.hasCodeCompletion())
@@ -5096,9 +5097,10 @@ Parser::parseDecl(ParseDeclOptions Flags,
   case tok::kw_extension:
     DeclResult = parseDeclExtension(Flags, Attributes);
     break;
+  case tok::kw_inout:
   case tok::kw_let:
   case tok::kw_var: {
-    parseLetOrVar(/*HasLetOrVarKeyword=*/true);
+    parseBindingIntroducer(/*HasLetOrVarKeyword=*/true);
     break;
   }
   case tok::kw_typealias:
@@ -5239,7 +5241,7 @@ Parser::parseDecl(ParseDeclOptions Flags,
         diagnose(Tok.getLoc(), diag::expected_keyword_in_decl, "var",
                  DescriptiveKind)
             .fixItInsert(Tok.getLoc(), "var ");
-        parseLetOrVar(/*HasLetOrVarKeyword=*/false);
+        parseBindingIntroducer(/*HasLetOrVarKeyword=*/false);
         break;
       }
 
@@ -7406,15 +7408,15 @@ void Parser::ParsedAccessors::classify(Parser &P, AbstractStorageDecl *storage,
 }
 
 
-/// Parse a 'var' or 'let' declaration, doing no token skipping on error.
+/// Parse a 'var', 'let', or 'inout' declaration, doing no token skipping on error.
 ParserResult<PatternBindingDecl>
 Parser::parseDeclVar(ParseDeclOptions Flags,
                      DeclAttributes &Attributes,
                      SmallVectorImpl<Decl *> &Decls,
                      SourceLoc StaticLoc,
                      StaticSpellingKind StaticSpelling,
                      SourceLoc TryLoc,
-                     bool HasLetOrVarKeyword) {
+                     bool HasBindingKeyword) {
   assert(StaticLoc.isInvalid() || StaticSpelling != StaticSpellingKind::None);
 
   if (StaticLoc.isValid()) {
@@ -7432,11 +7434,13 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
     }
   }
 
-  bool isLet = HasLetOrVarKeyword && Tok.is(tok::kw_let);
-  assert(!HasLetOrVarKeyword || Tok.getKind() == tok::kw_let ||
-         Tok.getKind() == tok::kw_var);
+  PatternBindingState newBindingContext = PatternBindingState::NotInBinding;
+  if (HasBindingKeyword)
+    newBindingContext = PatternBindingState(Tok);
+  assert(!HasBindingKeyword || Tok.getKind() == tok::kw_let ||
+         Tok.getKind() == tok::kw_var || Tok.getKind() == tok::kw_inout);
 
-  SourceLoc VarLoc = HasLetOrVarKeyword ? consumeToken() : Tok.getLoc();
+  SourceLoc VarLoc = newBindingContext.getIntroducer() ? consumeToken() : Tok.getLoc();
 
   // If this is a var in the top-level of script/repl source file, wrap the
   // PatternBindingDecl in a TopLevelCodeDecl, since it represents executable
@@ -7507,7 +7511,7 @@ Parser::parseDeclVar(ParseDeclOptions Flags,
       // In our recursive parse, remember that we're in a var/let pattern.
       llvm::SaveAndRestore<decltype(InBindingPattern)> T(
           InBindingPattern,
-          isLet ? PatternBindingState::InLet : PatternBindingState::InVar);
+          newBindingContext.getPatternBindingStateForIntroducer(VarDecl::Introducer::Var));
 
       // Track whether we are parsing an 'async let' pattern.
       const auto hasAsyncAttr = Attributes.hasAttribute<AsyncAttr>();

lib/Parse/ParseExpr.cpp

@@ -222,7 +222,7 @@ ParserResult<Expr> Parser::parseExprSequence(Diag<> Message,
       if (Tok.getText() == "&&" &&
           peekToken().isAny(tok::pound_available, tok::pound_unavailable,
                             tok::pound__hasSymbol, tok::kw_let, tok::kw_var,
-                            tok::kw_case))
+                            tok::kw_case, tok::kw_inout))
         goto done;
 
       // Parse the operator.
@@ -1635,8 +1635,7 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
     // will be resolved (or rejected) by sema when the overall refutable pattern
     // it transformed from an expression into a pattern.
     if ((InBindingPattern == PatternBindingState::ImplicitlyImmutable ||
-         InBindingPattern == PatternBindingState::InVar ||
-         InBindingPattern == PatternBindingState::InLet) &&
+         InBindingPattern.getIntroducer().hasValue()) &&
         // 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.

lib/Parse/ParsePattern.cpp

@@ -327,7 +327,7 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
 
     // If let or var is being used as an argument label, allow it but
     // generate a warning.
-    if (!isClosure && Tok.isAny(tok::kw_let, tok::kw_var)) {
+    if (!isClosure && Tok.isAny(tok::kw_let, tok::kw_var, tok::kw_inout)) {
       diagnose(Tok, diag::parameter_let_var_as_attr, Tok.getText())
         .fixItReplace(Tok.getLoc(), "`" + Tok.getText().str() + "`");
     }
@@ -1104,7 +1104,7 @@ ParserResult<Pattern> Parser::parsePattern() {
       consumeToken(tok::code_complete);
     }
     return makeParserCodeCompletionStatus();
-    
+  case tok::kw_inout:
   case tok::kw_var:
   case tok::kw_let: {
     auto newBindingState = PatternBindingState(Tok);
@@ -1273,8 +1273,8 @@ ParserResult<Pattern> Parser::parseMatchingPattern(bool isExprBasic) {
   // through the expr parser for ambiguous productions.
 
   // Parse productions that can only be patterns.
-  if (Tok.isAny(tok::kw_var, tok::kw_let)) {
-    assert(Tok.isAny(tok::kw_let, tok::kw_var) && "expects var or let");
+  if (Tok.isAny(tok::kw_var, tok::kw_let, tok::kw_inout)) {
+    assert(Tok.isAny(tok::kw_let, tok::kw_var, tok::kw_inout) && "expects var or let");
     auto newPatternBindingState = PatternBindingState(Tok);
     SourceLoc varLoc = consumeToken();
 
@@ -1356,7 +1356,7 @@ Parser::parseMatchingPatternAsBinding(PatternBindingState newState,
 }
 
 bool Parser::isOnlyStartOfMatchingPattern() {
-  return Tok.isAny(tok::kw_var, tok::kw_let, tok::kw_is);
+  return Tok.isAny(tok::kw_var, tok::kw_let, tok::kw_is, tok::kw_inout);
 }
 
 
@@ -1373,6 +1373,7 @@ static bool canParsePattern(Parser &P) {
   case tok::kw__:
     P.consumeToken();
     return true;
+  case tok::kw_inout:
   case tok::kw_let:
   case tok::kw_var:
     P.consumeToken();

lib/Parse/ParseStmt.cpp

@@ -1568,7 +1568,7 @@ Parser::parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,
 
   // Parse the basic expression case.  If we have a leading let/var/case
   // keyword or an assignment, then we know this is a binding.
-  if (Tok.isNot(tok::kw_let, tok::kw_var, tok::kw_case)) {
+  if (Tok.isNot(tok::kw_let, tok::kw_var, tok::kw_case, tok::kw_inout)) {
     // If we lack it, then this is theoretically a boolean condition.
     // However, we also need to handle migrating from Swift 2 syntax, in
     // which a comma followed by an expression could actually be a pattern
@@ -1600,7 +1600,7 @@ Parser::parseStmtConditionElement(SmallVectorImpl<StmtConditionElement> &result,
   }
 
   SourceLoc IntroducerLoc;
-  if (Tok.isAny(tok::kw_let, tok::kw_var, tok::kw_case)) {
+  if (Tok.isAny(tok::kw_let, tok::kw_var, tok::kw_case, tok::kw_inout)) {
     BindingKindStr = Tok.getText();
     IntroducerLoc = consumeToken();
   } else {

lib/Parse/Parser.cpp

@@ -747,7 +747,7 @@ void Parser::skipListUntilDeclRBrace(SourceLoc startLoc, tok T1, tok T2) {
 
       // Could have encountered something like `_ var:` 
       // or `let foo:` or `var:`
-      if (Tok.isAny(tok::kw_var, tok::kw_let)) {
+      if (Tok.isAny(tok::kw_var, tok::kw_let, tok::kw_inout)) {
         if (possibleDeclStartsLine && !hasDelimiter) {
           break;
         }

lib/Sema/TypeCheckPattern.cpp

@@ -290,7 +290,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
       if (!HasVariable) {
         Context.Diags
             .diagnose(P->getLoc(), diag::var_pattern_didnt_bind_variables,
-                      P->isLet() ? "let" : "var")
+                      P->getIntroducerStringRef())
             .highlight(P->getSubPattern()->getSourceRange())
             .fixItRemove(P->getLoc());
       }