Merge pull request #71990 from DougGregor/new-concurrency-lib-old-compiler-hacks

Introduce suppressible features so that the newer _Concurrency interface file can be handled by older compilers

Author: DougGregor

include/swift/AST/PrintOptions.h

@@ -372,6 +372,10 @@ struct PrintOptions {
   /// Whether to suppress printing of custom attributes that are expanded macros.
   bool SuppressExpandedMacros = true;
 
+  /// Whether we're supposed to slap a @rethrows on `AsyncSequence` /
+  /// `AsyncIteratorProtocol` for backward-compatibility reasons.
+  bool AsyncSequenceRethrows = false;
+
   /// List of attribute kinds that should not be printed.
   std::vector<AnyAttrKind> ExcludeAttrList = {
       DeclAttrKind::Transparent, DeclAttrKind::Effects,

include/swift/Basic/Features.def

@@ -109,6 +109,8 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(UnsafeInheritExecutor, 0, "@_unsafeInheritExecutor
 SUPPRESSIBLE_LANGUAGE_FEATURE(PrimaryAssociatedTypes2, 346, "Primary associated types")
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnavailableFromAsync, 0, "@_unavailableFromAsync")
 SUPPRESSIBLE_LANGUAGE_FEATURE(NoAsyncAvailability, 340, "@available(*, noasync)")
+SUPPRESSIBLE_LANGUAGE_FEATURE(AssociatedTypeAvailability, 0, "Availability on associated types")
+SUPPRESSIBLE_LANGUAGE_FEATURE(AsyncSequenceFailure, 0, "Failure associated type on AsyncSequence and AsyncIteratorProtocol")
 LANGUAGE_FEATURE(BuiltinIntLiteralAccessors, 368, "Builtin.IntLiteral accessors")
 LANGUAGE_FEATURE(Macros, 0, "Macros")
 LANGUAGE_FEATURE(FreestandingExpressionMacros, 382, "Expression macros")

lib/AST/ASTPrinter.cpp

@@ -1205,6 +1205,11 @@ static bool hasLessAccessibleSetter(const AbstractStorageDecl *ASD) {
   return ASD->getSetterFormalAccess() < ASD->getFormalAccess();
 }
 
+static bool isImplicitRethrowsProtocol(const ProtocolDecl *proto) {
+  return proto->isSpecificProtocol(KnownProtocolKind::AsyncSequence) ||
+      proto->isSpecificProtocol(KnownProtocolKind::AsyncIteratorProtocol);
+}
+
 void PrintAST::printAttributes(const Decl *D) {
   if (Options.SkipAttributes)
     return;
@@ -1215,6 +1220,17 @@ void PrintAST::printAttributes(const Decl *D) {
 
   auto attrs = D->getAttrs();
 
+  // When printing a Swift interface, make sure that older compilers see
+  // @rethrows on the AsyncSequence and AsyncIteratorProtocol.
+  if (Options.AsyncSequenceRethrows && Options.IsForSwiftInterface) {
+    if (auto proto = dyn_cast<ProtocolDecl>(D)) {
+      if (isImplicitRethrowsProtocol(proto)) {
+        Printer << "@rethrows";
+        Printer.printNewline();
+      }
+    }
+  }
+
   // Save the current number of exclude attrs to restore once we're done.
   unsigned originalExcludeAttrCount = Options.ExcludeAttrList.size();
 
@@ -3305,6 +3321,35 @@ static bool usesFeatureNoAsyncAvailability(Decl *decl) {
    return decl->getAttrs().getNoAsync(decl->getASTContext()) != nullptr;
 }
 
+static bool usesFeatureAssociatedTypeAvailability(Decl *decl) {
+  return isa<AssociatedTypeDecl>(decl) &&
+      decl->getAttrs().hasAttribute<AvailableAttr>();
+}
+
+static void
+suppressingFeatureAssociatedTypeAvailability(
+    PrintOptions &options, llvm::function_ref<void()> action) {
+  unsigned originalExcludeAttrCount = options.ExcludeAttrList.size();
+  options.ExcludeAttrList.push_back(DeclAttrKind::Available);
+  action();
+  options.ExcludeAttrList.resize(originalExcludeAttrCount);
+}
+
+static bool usesFeatureAsyncSequenceFailure(Decl *decl) {
+  if (auto proto = dyn_cast<ProtocolDecl>(decl)) {
+    return isImplicitRethrowsProtocol(proto);
+  }
+
+  return false;
+}
+
+static void
+suppressingFeatureAsyncSequenceFailure(
+    PrintOptions &options, llvm::function_ref<void()> action) {
+  llvm::SaveAndRestore<bool> saved(options.AsyncSequenceRethrows, true);
+  action();
+}
+
 static bool usesFeatureBuiltinIntLiteralAccessors(Decl *decl) {
   return false;
 }

lib/ASTGen/Sources/ASTGen/Diagnostics.swift

@@ -20,9 +20,7 @@ extension ASTGenError {
     MessageID(domain: "ASTGen", id: "\(Self.self)")
   }
 
-  var severity: DiagnosticSeverity {
-    .error
-  }
+  var severity: DiagnosticSeverity { .error }
 }
 
 /// An error emitted when a token is of an unexpected kind.

test/ModuleInterface/associated_type_availability.swift

@@ -0,0 +1,17 @@
+// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name assoc
+// RUN: %target-swift-typecheck-module-from-interface(%t.swiftinterface) -module-name assoc
+// RUN: %FileCheck %s < %t.swiftinterface
+
+// REQUIRES: concurrency, objc_interop
+
+// CHECK: public protocol P
+public protocol P {
+  // CHECK: #if compiler(>=5.3) && $AssociatedTypeAvailability
+  // CHECK-NEXT: @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+  // CHECK-NEXT: associatedtype AT = Self
+  // CHECK-NEXT: #else
+  // CHECK-NEXT: associatedtype AT = Self
+  // CHECK-NEXT: #endif
+  @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+  associatedtype AT = Self
+}

test/ModuleInterface/async_sequence_rethrows.swift

@@ -0,0 +1,10 @@
+// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name _Concurrency -disable-implicit-concurrency-module-import
+// RUN: %target-swift-typecheck-module-from-interface(%t.swiftinterface) -module-name _Concurrency -disable-implicit-concurrency-module-import
+// RUN: %FileCheck %s < %t.swiftinterface
+
+// REQUIRES: concurrency
+
+// CHECK: @rethrows
+// CHECK-NEXT: public protocol AsyncIteratorProtocol
+public protocol AsyncIteratorProtocol {
+}