[reference-bindings] Put reference bindings support behind -enable-experimental-feature ReferenceBindings.

gottesmm · gottesmm · commit 78d57ea6bed1 · 2023-03-03T17:14:16.000-08:00
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -964,6 +964,9 @@ 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{let||var}0' cannot appear nested inside another 'var' or "
+      "'let' pattern", (unsigned))
+ERROR(var_pattern_in_var_inout,none,
       "'%select{let|inout|var}0' cannot appear nested inside another 'var', "
       "'let', or 'inout' pattern", (unsigned))
 ERROR(extra_var_in_multiple_pattern_list,none,
diff --git a/include/swift/Basic/Features.def b/include/swift/Basic/Features.def
@@ -179,6 +179,9 @@ EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
 /// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
 EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
 
+/// Enable reference bindings.
+EXPERIMENTAL_FEATURE(ReferenceBindings, false)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -2057,7 +2057,7 @@ DeclNameRef formDeclNameRef(ASTContext &ctx,
                             bool isCxxClassTemplateSpec = false);
 
 /// Whether a given token can be the start of a decl.
-bool isKeywordPossibleDeclStart(const Token &Tok);
+bool isKeywordPossibleDeclStart(const LangOptions &options, const Token &Tok);
 
 } // end namespace swift
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -3220,6 +3220,11 @@ suppressingFeatureNoAsyncAvailability(PrintOptions &options,
   action();
 }
 
+static bool usesFeatureReferenceBindings(Decl *decl) {
+  auto *vd = dyn_cast<VarDecl>(decl);
+  return vd && vd->getIntroducer() == VarDecl::Introducer::InOut;
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -4659,8 +4659,11 @@ static unsigned skipUntilMatchingRBrace(Parser &P,
   return OpenBraces;
 }
 
-bool swift::isKeywordPossibleDeclStart(const Token &Tok) {
+bool swift::isKeywordPossibleDeclStart(const LangOptions &options,
+                                       const Token &Tok) {
   switch (Tok.getKind()) {
+  case tok::kw_inout:
+    return options.hasFeature(Feature::ReferenceBindings);
   case tok::at_sign:
   case tok::kw_associatedtype:
   case tok::kw_case:
@@ -4672,7 +4675,6 @@ 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:
@@ -4749,7 +4751,7 @@ bool Parser::isStartOfSwiftDecl(bool allowPoundIfAttributes) {
     // @rethrows does not follow the general rule of @<identifier> so
     // it is needed to short circuit this else there will be an infinite
     // loop on invalid attributes of just rethrows
-  } else if (!isKeywordPossibleDeclStart(Tok)) {
+  } else if (!isKeywordPossibleDeclStart(Context.LangOpts, Tok)) {
     // If this is obviously not the start of a decl, then we're done.
     return false;
   }
@@ -4878,7 +4880,7 @@ bool Parser::isStartOfSwiftDecl(bool allowPoundIfAttributes) {
     return true;
 
   // If the next token is obviously not the start of a decl, bail early.
-  if (!isKeywordPossibleDeclStart(Tok2))
+  if (!isKeywordPossibleDeclStart(Context.LangOpts, Tok2))
     return false;
   
   // Otherwise, do a recursive parse.
@@ -5091,7 +5093,6 @@ 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: {
     parseBindingIntroducer(/*HasLetOrVarKeyword=*/true);
@@ -5188,6 +5189,14 @@ Parser::parseDecl(ParseDeclOptions Flags,
   // Obvious nonsense.
   default:
 
+    // TODO: Once reference bindings is no longer experimental, move this into
+    // kw_let, kw_var.
+    if (Context.LangOpts.hasFeature(Feature::ReferenceBindings) &&
+        Tok.getKind() == tok::kw_inout) {
+      parseBindingIntroducer(/*HasLetOrVarKeyword=*/true);
+      break;
+    }
+
     if (Tok.isContextualKeyword("actor") && peekToken().is(tok::identifier)) {
       Tok.setKind(tok::contextual_keyword);
       DeclResult = parseDeclClass(Flags, Attributes);
diff --git a/lib/Parse/ParsePattern.cpp b/lib/Parse/ParsePattern.cpp
@@ -1105,15 +1105,25 @@ ParserResult<Pattern> Parser::parsePattern() {
     }
     return makeParserCodeCompletionStatus();
   case tok::kw_inout:
+    // If we don't have the reference binding feature, break if we have
+    // inout. Otherwise, go below.
+    if (!Context.LangOpts.hasFeature(Feature::ReferenceBindings))
+      break;
+    LLVM_FALLTHROUGH;
   case tok::kw_var:
   case tok::kw_let: {
     auto newBindingState = PatternBindingState(Tok);
     SourceLoc varLoc = consumeToken();
 
     // 'var', 'let', 'inout' patterns shouldn't nest.
-    if (InBindingPattern.getIntroducer().hasValue())
-      diagnose(varLoc, diag::var_pattern_in_var,
-               *newBindingState.getSelectIndexForIntroducer());
+    if (InBindingPattern.getIntroducer().hasValue()) {
+      auto diag = diag::var_pattern_in_var;
+      unsigned index = *newBindingState.getSelectIndexForIntroducer();
+      if (Context.LangOpts.hasFeature(Feature::ReferenceBindings)) {
+        diag = diag::var_pattern_in_var_inout;
+      }
+      diagnose(varLoc, diag, index);
+    }
 
     // 'let' isn't valid inside an implicitly immutable context, but var is.
     if (newBindingState.isLet() &&
@@ -1142,18 +1152,21 @@ ParserResult<Pattern> Parser::parsePattern() {
   }
       
   default:
-    if (Tok.isKeyword() &&
-        (peekToken().is(tok::colon) || peekToken().is(tok::equal))) {
-      diagnose(Tok, diag::keyword_cant_be_identifier, Tok.getText());
-      diagnose(Tok, diag::backticks_to_escape)
-        .fixItReplace(Tok.getLoc(), "`" + Tok.getText().str() + "`");
-      SourceLoc Loc = Tok.getLoc();
-      consumeToken();
-      return makeParserErrorResult(new (Context) AnyPattern(Loc));
-    }
-    diagnose(Tok, diag::expected_pattern);
-    return nullptr;
+    break;
   }
+
+  // Handle the default case.
+  if (Tok.isKeyword() &&
+      (peekToken().is(tok::colon) || peekToken().is(tok::equal))) {
+    diagnose(Tok, diag::keyword_cant_be_identifier, Tok.getText());
+    diagnose(Tok, diag::backticks_to_escape)
+      .fixItReplace(Tok.getLoc(), "`" + Tok.getText().str() + "`");
+    SourceLoc Loc = Tok.getLoc();
+    consumeToken();
+    return makeParserErrorResult(new (Context) AnyPattern(Loc));
+  }
+  diagnose(Tok, diag::expected_pattern);
+  return nullptr;
 }
 
 Pattern *Parser::createBindingFromPattern(SourceLoc loc, Identifier name,
@@ -1329,9 +1342,13 @@ ParserResult<Pattern>
 Parser::parseMatchingPatternAsBinding(PatternBindingState newState,
                                       SourceLoc varLoc, bool isExprBasic) {
   // 'var', 'let', 'inout' patterns shouldn't nest.
-  if (InBindingPattern.getIntroducer().hasValue())
-    diagnose(varLoc, diag::var_pattern_in_var,
+  if (InBindingPattern.getIntroducer().hasValue()) {
+    auto diag = diag::var_pattern_in_var;
+    if (Context.LangOpts.hasFeature(Feature::ReferenceBindings))
+      diag = diag::var_pattern_in_var_inout;
+    diagnose(varLoc, diag,
              *newState.getSelectIndexForIntroducer());
+  }
 
   // 'let' isn't valid inside an implicitly immutable context, but var is.
   if (newState.isLet() &&
diff --git a/test/Parse/matching_patterns.swift b/test/Parse/matching_patterns.swift
@@ -32,16 +32,12 @@ case let a:
   a = 1         // expected-error {{cannot assign}}
 case inout a:
   a = 1
-case var var a: // expected-error {{'var' cannot appear nested inside another 'var', 'let', or 'inout' pattern}}
+case var var a: // expected-error {{'var' cannot appear nested inside another 'var' or 'let' pattern}}
   a += 1
-case var let a: // expected-error {{'let' cannot appear nested inside another 'var', 'let', or 'inout' pattern}}
+case var let a: // expected-error {{'let' cannot appear nested inside another 'var' or 'let' pattern}}
   print(a, terminator: "")
 case var (var b): // expected-error {{'var' cannot appear nested inside another 'var'}}
   b += 1
-case var inout a: // expected-error {{'inout' cannot appear nested inside another 'var', 'let', or 'inout' pattern}}
-  break
-case inout (inout b): // expected-error {{'inout' cannot appear nested inside another 'var', 'let', or 'inout' pattern}}
-  break
 // 'Any' pattern.
 case _:
   ()
diff --git a/test/Parse/matching_patterns_reference_bindings.swift b/test/Parse/matching_patterns_reference_bindings.swift
diff --git a/test/Parse/pattern_without_variables.swift b/test/Parse/pattern_without_variables.swift
diff --git a/test/Parse/pattern_without_variables_reference_bindings.swift b/test/Parse/pattern_without_variables_reference_bindings.swift
