[AST] Add a new attribute @hasAsyncAlternative

This attribute marks a function has having an async alternative,
optionally providing the name of that function as a string. Intended to
be used to allow warnings when using a function with an async
alternative in an asynchronous context, to make the async refactorings
more accurate, and for documentation.

Author: bnbarham

include/swift/AST/Attr.def

@@ -624,6 +624,12 @@ SIMPLE_DECL_ATTR(reasync, AtReasync,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   110)
 
+DECL_ATTR(hasAsyncAlternative, HasAsyncAlternative,
+  OnAbstractFunction | ConcurrencyOnly |
+  ABIStableToAdd | ABIStableToRemove |
+  APIStableToAdd | APIStableToRemove,
+  111)
+
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/Attr.h

@@ -2140,6 +2140,30 @@ class TransposeAttr final
   }
 };
 
+/// The `@hasAsyncAlternative` attribute marks a function as having an async
+/// alternative, optionally providing a name (for cases when the alternative
+/// has a different name).
+class HasAsyncAlternativeAttr final : public DeclAttribute  {
+public:
+  /// An optional name of the async alternative function, where the name of the
+  /// attributed function is used otherwise.
+  const DeclNameRef Name;
+
+  HasAsyncAlternativeAttr(DeclNameRef Name, SourceLoc AtLoc, SourceRange Range)
+    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false),
+      Name(Name) {}
+
+  HasAsyncAlternativeAttr(SourceLoc AtLoc, SourceRange Range)
+    : DeclAttribute(DAK_HasAsyncAlternative, AtLoc, Range, false) {}
+
+  /// Determine whether this attribute has a name associated with it.
+  bool hasName() const { return !Name.getBaseName().empty(); }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_HasAsyncAlternative;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/DiagnosticsParse.def

@@ -1672,6 +1672,15 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
+// hasAsyncAlternative
+ERROR(requires_has_async_alternative, none,
+      "'%0' support is required to be explicitly enabled using "
+      "-experimental-has-async-alternative-attribute", (StringRef))
+
+ERROR(has_async_alternative_invalid_name, none,
+      "argument of '%0' attribute must be an identifier or full function name",
+      (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

include/swift/Basic/LangOptions.h

@@ -387,6 +387,9 @@ namespace swift {
     ASTVerifierOverrideKind ASTVerifierOverride =
         ASTVerifierOverrideKind::NoOverride;
 
+    /// Allow @hasAsyncAlternative attribute
+    bool EnableExperimentalHasAsyncAlternative = false;
+
     /// Sets the target we are building for and updates platform conditions
     /// to match.
     ///

include/swift/Option/FrontendOptions.td

@@ -796,4 +796,9 @@ def disable_ast_verifier : Flag<["-"], "disable-ast-verifier">,
 def new_driver_path
   : Separate<["-"], "new-driver-path">, MetaVarName<"<path>">,
   HelpText<"Path of the new driver to be used">;
+
+def experimental_has_async_alternative_attribute:
+  Flag<["-"], "experimental-has-async-alternative-attribute">,
+  HelpText<"Allow use of @hasAsyncAlternative">;
+
 } // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]

lib/AST/Attr.cpp

@@ -1223,6 +1223,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "derivative";
   case DAK_Transpose:
     return "transpose";
+  case DAK_HasAsyncAlternative:
+    return "hasAsyncAlternative";
   }
   llvm_unreachable("bad DeclAttrKind");
 }

lib/Frontend/CompilerInvocation.cpp

@@ -715,6 +715,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
     }
   }
 
+  Opts.EnableExperimentalHasAsyncAlternative |=
+      Args.hasArg(OPT_experimental_has_async_alternative_attribute);
+
   return HadError || UnsupportedOS || UnsupportedArch;
 }
 

lib/Parse/ParseDecl.cpp

@@ -1570,6 +1570,44 @@ void Parser::parseAllAvailabilityMacroArguments() {
   AvailabilityMacrosComputed = true;
 }
 
+static HasAsyncAlternativeAttr *parseAsyncAlternativeAttribute(
+    Parser &P, StringRef AttrName, SourceLoc AtLoc, DeclAttrKind DK) {
+  SourceLoc Loc = P.PreviousLoc;
+
+  // Unnamed @hasAsyncAlternative attribute
+  if (P.Tok.isNot(tok::l_paren))
+    return new (P.Context) HasAsyncAlternativeAttr(AtLoc, Loc);
+
+  P.consumeToken(tok::l_paren);
+
+  if (!P.Tok.is(tok::string_literal)) {
+    P.diagnose(Loc, diag::attr_expected_string_literal, AttrName);
+    return nullptr;
+  }
+
+  auto Value = P.getStringLiteralIfNotInterpolated(
+      Loc, ("argument of '" + AttrName + "'").str());
+  P.consumeToken(tok::string_literal);
+  if (!Value)
+    return nullptr;
+
+  ParsedDeclName parsedName = parseDeclName(Value.getValue());
+  if (!parsedName || !parsedName.ContextName.empty()) {
+    P.diagnose(AtLoc, diag::has_async_alternative_invalid_name, AttrName);;
+    return nullptr;
+  }
+
+  SourceRange AttrRange = SourceRange(Loc, P.Tok.getRange().getStart());
+  if (!P.consumeIf(tok::r_paren)) {
+    P.diagnose(Loc, diag::attr_expected_rparen, AttrName,
+               DeclAttribute::isDeclModifier(DK));
+    return nullptr;
+  }
+
+  return new (P.Context) HasAsyncAlternativeAttr(
+      parsedName.formDeclNameRef(P.Context), AtLoc, AttrRange);
+}
+
 bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
                                    DeclAttrKind DK, bool isFromClangAttribute) {
   // Ok, it is a valid attribute, eat it, and then process it.
@@ -2648,6 +2686,22 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
         name, AtLoc, range, /*implicit*/ false));
     break;
   }
+  case DAK_HasAsyncAlternative: {
+    auto *attr = parseAsyncAlternativeAttribute(*this, AttrName, AtLoc, DK);
+    if (!attr) {
+      skipUntilDeclStmtRBrace(tok::r_paren);
+      consumeIf(tok::r_paren);
+      return false;
+    }
+
+    if (!DiscardAttribute) {
+      if (Context.LangOpts.EnableExperimentalHasAsyncAlternative)
+        Attributes.add(attr);
+      else
+        diagnose(Loc, diag::requires_has_async_alternative, AttrName);
+    }
+    break;
+  }
   }
 
   if (DuplicateAttribute) {

lib/Sema/TypeCheckAttr.cpp

@@ -105,6 +105,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(Effects)
   IGNORED_ATTR(Exported)
   IGNORED_ATTR(ForbidSerializingReference)
+  IGNORED_ATTR(HasAsyncAlternative)
   IGNORED_ATTR(HasStorage)
   IGNORED_ATTR(HasMissingDesignatedInitializers)
   IGNORED_ATTR(InheritsConvenienceInitializers)

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1446,6 +1446,7 @@ namespace  {
     UNINTERESTING_ATTR(Exported)
     UNINTERESTING_ATTR(ForbidSerializingReference)
     UNINTERESTING_ATTR(GKInspectable)
+    UNINTERESTING_ATTR(HasAsyncAlternative)
     UNINTERESTING_ATTR(HasMissingDesignatedInitializers)
     UNINTERESTING_ATTR(IBAction)
     UNINTERESTING_ATTR(IBDesignable)