Add optional message to unavailablefromasync

Adding the ability to add an optional message to the unavailable from
async attribute. This can be used to indicate other possible API to use,
or help explain why it's unavailable.

Author: etcwilde

include/swift/AST/Attr.def

@@ -699,7 +699,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_const, CompileTimeConst,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   126)
 
-SIMPLE_DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
+DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
   OnFunc | OnConstructor | UserInaccessible |
   ABIStableToAdd | ABIStableToRemove |
   APIBreakingToAdd | APIStableToRemove,

include/swift/AST/Attr.h

@@ -2085,6 +2085,26 @@ class TypeSequenceAttr : public DeclAttribute {
   }
 };
 
+/// The @_unavailableFromAsync attribute, used to make function declarations
+/// unavailable from async contexts.
+class UnavailableFromAsyncAttr : public DeclAttribute {
+public:
+  UnavailableFromAsyncAttr(StringRef Message, SourceLoc AtLoc,
+                           SourceRange Range, bool Implicit)
+      : DeclAttribute(DAK_UnavailableFromAsync, AtLoc, Range, Implicit),
+        Message(Message) {}
+  UnavailableFromAsyncAttr(StringRef Message, bool Implicit)
+      : UnavailableFromAsyncAttr(Message, SourceLoc(), SourceRange(),
+                                 Implicit) {}
+  const StringRef Message;
+
+  bool hasMessage() const { return !Message.empty(); }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_UnavailableFromAsync;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/DiagnosticsSema.def

@@ -4719,7 +4719,8 @@ ERROR(async_named_decl_must_be_available_from_async,none,
         "asynchronous %0 %1 must be available from asynchronous contexts",
         (DescriptiveDeclKind, DeclName))
 ERROR(async_unavailable_decl,none,
-      "%0 %1 is unavailable from asynchronous contexts", (DescriptiveDeclKind, DeclBaseName))
+      "%0 %1 is unavailable from asynchronous contexts%select{|; %3}2",
+      (DescriptiveDeclKind, DeclBaseName, bool, StringRef))
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Types

lib/AST/Attr.cpp

@@ -1164,6 +1164,17 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DAK_UnavailableFromAsync: {
+    Printer.printAttrName("@_unavailableFromAsync");
+    const UnavailableFromAsyncAttr *attr = cast<UnavailableFromAsyncAttr>(this);
+    if (attr->hasMessage()) {
+      Printer << "(message: \"";
+      Printer << attr->Message;
+      Printer << "\")";
+    }
+    break;
+  }
+
   case DAK_Count:
     llvm_unreachable("exceed declaration attribute kinds");
 
@@ -1317,6 +1328,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "transpose";
   case DAK_TypeSequence:
     return "_typeSequence";
+  case DAK_UnavailableFromAsync:
+    return "_unavailableFromAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }

lib/Parse/ParseDecl.cpp

@@ -2749,6 +2749,45 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     Attributes.add(TypeSequenceAttr::create(Context, AtLoc, range));
     break;
   }
+
+  case DAK_UnavailableFromAsync: {
+
+    StringRef message;
+    if (consumeIf(tok::l_paren)) {
+      if (!Tok.is(tok::identifier)) {
+        llvm_unreachable("Flag must start with an indentifier");
+      }
+
+      StringRef flag = Tok.getText();
+
+      if (flag != "message") {
+        llvm_unreachable("Unknown unavailable argument");
+      }
+      consumeToken();
+      if (!consumeIf(tok::colon)) {
+        llvm_unreachable("Expected ':' following 'message'");
+      }
+      if (!Tok.is(tok::string_literal)) {
+        llvm_unreachable("Expected string literal");
+      }
+
+      Optional<StringRef> value = getStringLiteralIfNotInterpolated(
+          Loc, "' I don't know what goes here! '");
+      if (!value)
+        llvm_unreachable("Expected a message, homie");
+
+      consumeToken();
+
+      message = *value;
+
+      if (!consumeIf(tok::r_paren))
+        llvm_unreachable("Expected a closing r-paren");
+    }
+
+    Attributes.add(new (Context) UnavailableFromAsyncAttr(
+        message, AtLoc, SourceRange(Loc, Tok.getLoc()), false));
+    break;
+  }
   }
 
   if (DuplicateAttribute) {

lib/Sema/TypeCheckAvailability.cpp

@@ -3149,10 +3149,12 @@ diagnoseDeclUnavailableFromAsync(const ValueDecl *D, SourceRange R,
     return false;
 
   ASTContext &ctx = Where.getDeclContext()->getASTContext();
+  const UnavailableFromAsyncAttr *attr =
+      D->getAttrs().getAttribute<UnavailableFromAsyncAttr>();
   SourceLoc diagLoc = call ? call->getLoc() : R.Start;
   ctx.Diags
       .diagnose(diagLoc, diag::async_unavailable_decl, D->getDescriptiveKind(),
-                D->getBaseName())
+                D->getBaseName(), attr->hasMessage(), attr->Message)
       .warnUntilSwiftVersion(6);
   D->diagnose(diag::decl_declared_here, D->getName());
   return true;

lib/Serialization/Deserialization.cpp

@@ -4747,6 +4747,14 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         break;
       }
 
+      case decls_block::UnavailableFromAsync_DECL_ATTR: {
+        bool isImplicit;
+        serialization::decls_block::UnavailableFromAsyncDeclAttrLayout::
+            readRecord(scratch, isImplicit);
+        Attr = new (ctx) UnavailableFromAsyncAttr(blobData, isImplicit);
+        break;
+      }
+
 #define SIMPLE_DECL_ATTR(NAME, CLASS, ...) \
       case decls_block::CLASS##_DECL_ATTR: { \
         bool isImplicit; \

lib/Serialization/ModuleFormat.h

@@ -2022,6 +2022,12 @@ namespace decls_block {
     TypeIDField, // type referenced by this custom attribute
     BCFixed<1>   // is the argument (unsafe)
   >;
+
+  using UnavailableFromAsyncDeclAttrLayout = BCRecordLayout<
+    UnavailableFromAsync_DECL_ATTR,
+    BCFixed<1>, // Implicit flag
+    BCBlob      // Message
+  >;
 }
 
 /// Returns the encoding kind for the given decl.

lib/Serialization/Serialization.cpp

@@ -2754,6 +2754,16 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       TypeSequenceDeclAttrLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode);
       return;
     }
+
+    case DAK_UnavailableFromAsync: {
+      auto abbrCode =
+          S.DeclTypeAbbrCodes[UnavailableFromAsyncDeclAttrLayout::Code];
+      auto *theAttr = cast<UnavailableFromAsyncAttr>(DA);
+      UnavailableFromAsyncDeclAttrLayout::emitRecord(
+          S.Out, S.ScratchRecord, abbrCode, theAttr->isImplicit(),
+          theAttr->Message);
+      return;
+    }
     }
   }
 

test/ClangImporter/objc_async.swift

@@ -45,7 +45,8 @@ func testSlowServer(slowServer: SlowServer) async throws {
   let _: Int = await slowServer.bestName("hello")
   let _: Int = await slowServer.customize("hello")
 
-  slowServer.unavailableMethod() // expected-warning{{'unavailableMethod' is unavailable from asynchronous contexts}}
+  slowServer.unavailableMethod() // expected-warning{{instance method 'unavailableMethod' is unavailable from asynchronous contexts}}
+  slowServer.unavailableMethodWithMessage() // expected-warning{{instance method 'unavailableMethodWithMessage' is unavailable from asynchronous contexts; Blarpy!}}
 
   let _: String = await slowServer.dance("slide")
   let _: String = await slowServer.__leap(17)