Parse: Require a "before: " label in the first item of the list in the @_backDeploy attribute in order to match the pitched syntax for the attribute. Refactor existing comma separated list parsing code to take advantage of part of it in the attribute parsing.

tshortli · tshortli · commit 2a646dc4381b · 2022-03-18T11:31:34.000-07:00
diff --git a/docs/ReferenceGuides/UnderscoredAttributes.md b/docs/ReferenceGuides/UnderscoredAttributes.md
@@ -39,14 +39,19 @@ Most notably, default argument expressions are implicitly
 `@_alwaysEmitIntoClient`, which means that adding a default argument to a
 function which did not have one previously does not break ABI.
 
-## `@_backDeploy(availabilitySpec ...)`
+## `@_backDeploy(before: ...)`
 
 Causes the body of a function to be emitted into the module interface to be
-available for inlining in clients with deployment targets lower than the formal
-availability of the function. When inlined, the body of the function is
-transformed such that it calls the library's copy of the function if it is
-available at runtime. Otherwise, the copy of the original function body is
-executed.
+available for emission into clients with deployment targets lower than the
+ABI availability of the function. When the client's deployment target is
+before the function's ABI availability, the compiler replaces calls to that
+function with a call to a thunk that checks at runtime whether the original
+library function is available. If the the original is available then it is
+called. Otherwise, the fallback copy of the function that was emitted into the
+client is called instead.
+
+For more details, see the [pitch thread](https://forums.swift.org/t/pitch-function-back-deployment/55769/)
+in the forums.
 
 ## `@_assemblyVision`
 
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -1572,6 +1572,10 @@ ERROR(originally_defined_in_need_nonempty_module_name,none,
       "original module name cannot be empty in @_originallyDefinedIn", ())
 
 // backDeploy
+ERROR(attr_back_deploy_expected_before_label,none,
+      "expected 'before:' in '@_backDeploy' attribute", ())
+ERROR(attr_back_deploy_expected_colon_after_before,none,
+      "expected ':' after 'before' in '@_backDeploy' attribute", ())
 ERROR(attr_back_deploy_missing_rparen,none,
       "expected ')' in '@_backDeploy' argument list", ())
 
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -895,6 +895,22 @@ class Parser {
   /// close brace.
   SourceLoc getErrorOrMissingLoc() const;
 
+  enum class ParseListItemResult {
+    /// There are more list items to parse.
+    Continue,
+    /// The list ended inside a string literal interpolation context.
+    FinishedInStringInterpolation,
+    /// The list ended for another reason.
+    Finished,
+  };
+
+  /// Parses a single item from a comma separated list and updates `Status`.
+  ParseListItemResult
+  parseListItem(ParserStatus &Status, tok RightK, SourceLoc LeftLoc,
+                SourceLoc &RightLoc, bool AllowSepAfterLast,
+                SyntaxKind ElementKind,
+                llvm::function_ref<ParserStatus()> callback);
+
   /// Parse a comma separated list of some elements.
   ParserStatus parseList(tok RightK, SourceLoc LeftLoc, SourceLoc &RightLoc,
                          bool AllowSepAfterLast, Diag<> ErrorDiag,
@@ -1070,6 +1086,10 @@ class Parser {
   ParserResult<TransposeAttr> parseTransposeAttribute(SourceLoc AtLoc,
                                                       SourceLoc Loc);
 
+  /// Parse the @_backDeploy attribute.
+  bool parseBackDeployAttribute(DeclAttributes &Attributes, StringRef AttrName,
+                                SourceLoc AtLoc, SourceLoc Loc);
+
   /// Parse a specific attribute.
   ParserStatus parseDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
                                   PatternBindingInitializer *&initContext,
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -1215,7 +1215,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
 
   case DAK_BackDeploy: {
     Printer.printAttrName("@_backDeploy");
-    Printer << "(";
+    Printer << "(before: ";
     auto Attr = cast<BackDeployAttr>(this);
     Printer << platformString(Attr->Platform) << " " <<
       Attr->Version.getAsString();
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -1824,6 +1824,76 @@ ParserStatus Parser::parsePlatformVersionInList(StringRef AttrName,
   return makeParserSuccess();
 }
 
+bool Parser::parseBackDeployAttribute(DeclAttributes &Attributes,
+                                      StringRef AttrName, SourceLoc AtLoc,
+                                      SourceLoc Loc) {
+  std::string AtAttrName = (llvm::Twine("@") + AttrName).str();
+  auto LeftLoc = Tok.getLoc();
+  if (!consumeIf(tok::l_paren)) {
+    diagnose(Loc, diag::attr_expected_lparen, AtAttrName,
+             DeclAttribute::isDeclModifier(DAK_BackDeploy));
+    return false;
+  }
+
+  SourceLoc RightLoc;
+  ParserStatus Status;
+  bool SuppressLaterDiags = false;
+  llvm::SmallVector<PlatformAndVersion, 4> PlatformAndVersions;
+
+  {
+    SyntaxParsingContext SpecListListContext(
+        SyntaxContext, SyntaxKind::BackDeployAttributeSpecList);
+
+    // Parse 'before' ':'.
+    if (Tok.is(tok::identifier) && Tok.getText() == "before") {
+      consumeToken();
+      if (!consumeIf(tok::colon))
+        diagnose(Tok, diag::attr_back_deploy_expected_colon_after_before);
+    } else {
+      diagnose(Tok, diag::attr_back_deploy_expected_before_label);
+    }
+
+    // Parse the version list.
+    if (!Tok.is(tok::r_paren)) {
+      SyntaxParsingContext VersionListContext(
+          SyntaxContext, SyntaxKind::BackDeployVersionList);
+
+      ParseListItemResult Result;
+      do {
+        Result = parseListItem(Status, tok::r_paren, LeftLoc, RightLoc,
+                               /*AllowSepAfterLast=*/false,
+                               SyntaxKind::BackDeployVersionArgument,
+                               [&]() -> ParserStatus {
+                                 return parsePlatformVersionInList(
+                                     AtAttrName, PlatformAndVersions);
+                               });
+      } while (Result == ParseListItemResult::Continue);
+    }
+  }
+
+  if (parseMatchingToken(tok::r_paren, RightLoc,
+                         diag::attr_back_deploy_missing_rparen, LeftLoc))
+    return false;
+
+  if (Status.isErrorOrHasCompletion() || SuppressLaterDiags) {
+    return false;
+  }
+
+  if (PlatformAndVersions.empty()) {
+    diagnose(Loc, diag::attr_availability_need_platform_version, AtAttrName);
+    return false;
+  }
+
+  assert(!PlatformAndVersions.empty());
+  auto AttrRange = SourceRange(Loc, Tok.getLoc());
+  for (auto &Item : PlatformAndVersions) {
+    Attributes.add(new (Context)
+                       BackDeployAttr(AtLoc, AttrRange, Item.first, Item.second,
+                                      /*IsImplicit*/ false));
+  }
+  return true;
+}
+
 /// Processes a parsed option name by attempting to match it to a list of
 /// alternative name/value pairs provided by a chain of \c when() calls, ending
 /// in either \c whenOmitted() if omitting the option is allowed, or
@@ -2858,45 +2928,8 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     break;
   }
   case DAK_BackDeploy: {
-    auto LeftLoc = Tok.getLoc();
-    if (!consumeIf(tok::l_paren)) {
-      diagnose(Loc, diag::attr_expected_lparen, AttrName,
-               DeclAttribute::isDeclModifier(DK));
-      return false;
-    }
-
-    bool SuppressLaterDiags = false;
-    SourceLoc RightLoc;
-    llvm::SmallVector<PlatformAndVersion, 4> PlatformAndVersions;
-    StringRef AttrName = "@_backDeploy";
-    ParserStatus Status = parseList(tok::r_paren, LeftLoc, RightLoc, false,
-                                    diag::attr_back_deploy_missing_rparen,
-                                    SyntaxKind::AvailabilitySpecList,
-                                    [&]() -> ParserStatus {
-      ParserStatus ListItemStatus =
-          parsePlatformVersionInList(AttrName, PlatformAndVersions);
-      if (ListItemStatus.isErrorOrHasCompletion())
-        SuppressLaterDiags = true;
-      return ListItemStatus;
-    });
-
-    if (Status.isErrorOrHasCompletion() || SuppressLaterDiags) {
-      return false;
-    }
-
-    if (PlatformAndVersions.empty()) {
-      diagnose(Loc, diag::attr_availability_need_platform_version, AttrName);
+    if (!parseBackDeployAttribute(Attributes, AttrName, AtLoc, Loc))
       return false;
-    }
-    
-    assert(!PlatformAndVersions.empty());
-    AttrRange = SourceRange(Loc, Tok.getLoc());
-    for (auto &Item: PlatformAndVersions) {
-      Attributes.add(new (Context) BackDeployAttr(AtLoc, AttrRange,
-                                                  Item.first,
-                                                  Item.second,
-                                                  /*IsImplicit*/false));
-    }
     break;
   }
   }
diff --git a/lib/Parse/Parser.cpp b/lib/Parse/Parser.cpp
@@ -1061,14 +1061,72 @@ static SyntaxKind getListElementKind(SyntaxKind ListKind) {
   }
 }
 
+static bool tokIsStringInterpolationEOF(Token &Tok, tok RightK) {
+  return Tok.is(tok::eof) && Tok.getText() == ")" && RightK == tok::r_paren;
+}
+
+Parser::ParseListItemResult
+Parser::parseListItem(ParserStatus &Status, tok RightK, SourceLoc LeftLoc,
+                      SourceLoc &RightLoc, bool AllowSepAfterLast,
+                      SyntaxKind ElementKind,
+                      llvm::function_ref<ParserStatus()> callback) {
+  while (Tok.is(tok::comma)) {
+    diagnose(Tok, diag::unexpected_separator, ",").fixItRemove(Tok.getLoc());
+    consumeToken();
+  }
+  SourceLoc StartLoc = Tok.getLoc();
+
+  SyntaxParsingContext ElementContext(SyntaxContext, ElementKind);
+  if (ElementKind == SyntaxKind::Unknown)
+    ElementContext.setTransparent();
+  Status |= callback();
+  if (Tok.is(RightK))
+    return ParseListItemResult::Finished;
+
+  // If the lexer stopped with an EOF token whose spelling is ")", then this
+  // is actually the tuple that is a string literal interpolation context.
+  // Just accept the ")" and build the tuple as we usually do.
+  if (tokIsStringInterpolationEOF(Tok, RightK)) {
+    RightLoc = Tok.getLoc();
+    return ParseListItemResult::FinishedInStringInterpolation;
+  }
+  // If we haven't made progress, or seeing any error, skip ahead.
+  if (Tok.getLoc() == StartLoc || Status.isErrorOrHasCompletion()) {
+    assert(Status.isErrorOrHasCompletion() && "no progress without error");
+    skipListUntilDeclRBrace(LeftLoc, RightK, tok::comma);
+    if (Tok.is(RightK) || Tok.isNot(tok::comma))
+      return ParseListItemResult::Finished;
+  }
+  if (consumeIf(tok::comma)) {
+    if (Tok.isNot(RightK))
+      return ParseListItemResult::Continue;
+    if (!AllowSepAfterLast) {
+      diagnose(Tok, diag::unexpected_separator, ",").fixItRemove(PreviousLoc);
+    }
+    return ParseListItemResult::Finished;
+  }
+  // If we're in a comma-separated list, the next token is at the
+  // beginning of a new line and can never start an element, break.
+  if (Tok.isAtStartOfLine() &&
+      (Tok.is(tok::r_brace) || isStartOfSwiftDecl() || isStartOfStmt())) {
+    return ParseListItemResult::Finished;
+  }
+  // If we found EOF or such, bailout.
+  if (Tok.isAny(tok::eof, tok::pound_endif)) {
+    IsInputIncomplete = true;
+    return ParseListItemResult::Finished;
+  }
+
+  diagnose(Tok, diag::expected_separator, ",")
+      .fixItInsertAfter(PreviousLoc, ",");
+  Status.setIsParseError();
+  return ParseListItemResult::Continue;
+}
+
 ParserStatus
 Parser::parseList(tok RightK, SourceLoc LeftLoc, SourceLoc &RightLoc,
                   bool AllowSepAfterLast, Diag<> ErrorDiag, SyntaxKind Kind,
                   llvm::function_ref<ParserStatus()> callback) {
-  auto TokIsStringInterpolationEOF = [&]() -> bool {
-    return Tok.is(tok::eof) && Tok.getText() == ")" && RightK == tok::r_paren;
-  };
-  
   llvm::Optional<SyntaxParsingContext> ListContext;
   ListContext.emplace(SyntaxContext, Kind);
   if (Kind == SyntaxKind::Unknown)
@@ -1081,64 +1139,20 @@ Parser::parseList(tok RightK, SourceLoc LeftLoc, SourceLoc &RightLoc,
     RightLoc = consumeToken(RightK);
     return makeParserSuccess();
   }
-  if (TokIsStringInterpolationEOF()) {
+  if (tokIsStringInterpolationEOF(Tok, RightK)) {
     RightLoc = Tok.getLoc();
     return makeParserSuccess();
   }
 
   ParserStatus Status;
-  while (true) {
-    while (Tok.is(tok::comma)) {
-      diagnose(Tok, diag::unexpected_separator, ",")
-        .fixItRemove(Tok.getLoc());
-      consumeToken();
-    }
-    SourceLoc StartLoc = Tok.getLoc();
-
-    SyntaxParsingContext ElementContext(SyntaxContext, ElementKind);
-    if (ElementKind == SyntaxKind::Unknown)
-      ElementContext.setTransparent();
-    Status |= callback();
-    if (Tok.is(RightK))
-      break;
-    // If the lexer stopped with an EOF token whose spelling is ")", then this
-    // is actually the tuple that is a string literal interpolation context.
-    // Just accept the ")" and build the tuple as we usually do.
-    if (TokIsStringInterpolationEOF()) {
-      RightLoc = Tok.getLoc();
-      return Status;
-    }
-    // If we haven't made progress, or seeing any error, skip ahead.
-    if (Tok.getLoc() == StartLoc || Status.isErrorOrHasCompletion()) {
-      assert(Status.isErrorOrHasCompletion() && "no progress without error");
-      skipListUntilDeclRBrace(LeftLoc, RightK, tok::comma);
-      if (Tok.is(RightK) || Tok.isNot(tok::comma))
-        break;
-    }
-    if (consumeIf(tok::comma)) {
-      if (Tok.isNot(RightK))
-        continue;
-      if (!AllowSepAfterLast) {
-        diagnose(Tok, diag::unexpected_separator, ",")
-          .fixItRemove(PreviousLoc);
-      }
-      break;
-    }
-    // If we're in a comma-separated list, the next token is at the
-    // beginning of a new line and can never start an element, break.
-    if (Tok.isAtStartOfLine() &&
-        (Tok.is(tok::r_brace) || isStartOfSwiftDecl() || isStartOfStmt())) {
-      break;
-    }
-    // If we found EOF or such, bailout.
-    if (Tok.isAny(tok::eof, tok::pound_endif)) {
-      IsInputIncomplete = true;
-      break;
-    }
+  ParseListItemResult Result;
+  do {
+    Result = parseListItem(Status, RightK, LeftLoc, RightLoc, AllowSepAfterLast,
+                           ElementKind, callback);
+  } while (Result == ParseListItemResult::Continue);
 
-    diagnose(Tok, diag::expected_separator, ",")
-      .fixItInsertAfter(PreviousLoc, ",");
-    Status.setIsParseError();
+  if (Result == ParseListItemResult::FinishedInStringInterpolation) {
+    return Status;
   }
 
   ListContext.reset();
diff --git a/test/attr/attr_backDeploy.swift b/test/attr/attr_backDeploy.swift
@@ -304,10 +304,34 @@ public func unknownMacroVersionned() {}
 @_backDeploy(before: _unknownMacro 1.0, _myProject 2.0) // expected-warning {{unknown platform '_unknownMacro' for attribute '@_backDeploy'}}
 public func knownAndUnknownMacroVersionned() {}
 
-@_backDeploy() // expected-error {{expected at least one platform version in '@_backDeploy' attribute}}
+@_backDeploy() // expected-error {{expected 'before:' in '@_backDeploy' attribute}}
+// expected-error@-1 {{expected at least one platform version in '@_backDeploy' attribute}}
+public func emptyAttributeFunc() {}
+
+@available(macOS 11.0, *)
+@_backDeploy(macOS 12.0) // expected-error {{expected 'before:' in '@_backDeploy' attribute}}
+public func missingBeforeFunc() {}
+
+@_backDeploy(before) // expected-error {{expected ':' after 'before' in '@_backDeploy' attribute}}
+// expected-error@-1 {{expected at least one platform version in '@_backDeploy' attribute}}
+public func missingColonAfterBeforeFunc() {}
+
+@available(macOS 11.0, *)
+@_backDeploy(before macOS 12.0) // expected-error {{expected ':' after 'before' in '@_backDeploy' attribute}}
+public func missingColonBetweenBeforeAndPlatformFunc() {}
+
+@available(macOS 11.0, *)
+@_backDeploy(before: macOS 12.0,) // expected-error {{unexpected ',' separator}}
+public func unexpectedTrailingCommaFunc() {}
+
+@available(macOS 11.0, iOS 14.0, *)
+@_backDeploy(before: macOS 12.0,, iOS 15.0) // expected-error {{unexpected ',' separator}}
+public func extraCommaFunc() {}
+
+@_backDeploy(before:) // expected-error {{expected at least one platform version in '@_backDeploy' attribute}}
 public func emptyPlatformVersionsFunc() {}
 
-@_backDeploy // expected-error {{expected '(' in '_backDeploy' attribute}}
+@_backDeploy // expected-error {{expected '(' in '@_backDeploy' attribute}}
 public func expectedLeftParenFunc() {}
 
 @_backDeploy(before: macOS 12.0 // expected-note {{to match this opening '('}}
diff --git a/utils/gyb_syntax_support/AttributeNodes.py b/utils/gyb_syntax_support/AttributeNodes.py
diff --git a/utils/gyb_syntax_support/NodeSerializationCodes.py b/utils/gyb_syntax_support/NodeSerializationCodes.py
