AST: Emit correct synthesized availability attributes for unownedExecutor property.

When synthesizing a declaration and inferring its availability, the synthesized attribute should factor in unavailability of the parent declarations. This recently regressed with #63361. However, the previous implementation did not produce correct results, either, because the logic for merging availability attributes produced a non-sensical result when both `unavailable` and `introduced:` availability attributes were merged. For example, this was the result for the synthesized `unownedExecutor` property of an actor when the actor was marked unavailable:

```
@available(macOS, unavailable)
actor A {
  // Incorrectly synthesized availability for `unownedExecutor` which results from merging
  // the unavailability of the parent and the availability of the UnownedSerialExecutor type.
  @available(macOS, unavailable, introduced: macOS 10.15)
  @_semantics("defaultActor") nonisolated final var unownedExecutor: UnownedSerialExecutor { get }
}
```

This is fixed by omitting all version components from the synthesized attribute when the overall attribute kind is "unavailable".

Additionally, I discovered that the `concurrency_availability.swift` test case was no longer testing what it intended to test. The conformances to `Actor` for each `actor` in the test were no longer being synthesized and therefore `unownedExecutor` was not being synthesized. That was fixed by importing the `_Concurrency` module directly, which seems to be necessary because of the `-parse-stdlib` flag in the test.

Resolves rdar://106055566

Author: tshortli

include/swift/AST/Availability.h

@@ -334,6 +334,10 @@ class AvailabilityContext {
 
 class AvailabilityInference {
 public:
+  /// Returns the decl that should be considered the parent decl of the given
+  /// decl when looking for inherited availability annotations.
+  static const Decl *parentDeclForInferredAvailability(const Decl *D);
+
   /// Infers the common availability required to access an array of
   /// declarations and adds attributes reflecting that availability
   /// to ToDecl.

lib/AST/Availability.cpp

@@ -102,14 +102,22 @@ static AvailableAttr *createAvailableAttr(PlatformKind Platform,
                                           StringRef Rename,
                                           ValueDecl *RenameDecl,
                                           ASTContext &Context) {
-
   llvm::VersionTuple Introduced =
       Inferred.Introduced.value_or(llvm::VersionTuple());
   llvm::VersionTuple Deprecated =
       Inferred.Deprecated.value_or(llvm::VersionTuple());
   llvm::VersionTuple Obsoleted =
       Inferred.Obsoleted.value_or(llvm::VersionTuple());
 
+  // If a decl is unavailable then it cannot have any introduced, deprecated, or
+  // obsoleted version.
+  if (Inferred.PlatformAgnostic ==
+      PlatformAgnosticAvailabilityKind::Unavailable) {
+    Introduced = llvm::VersionTuple();
+    Deprecated = llvm::VersionTuple();
+    Obsoleted = llvm::VersionTuple();
+  }
+
   return new (Context)
       AvailableAttr(SourceLoc(), SourceRange(), Platform,
                     Message, Rename, RenameDecl,
@@ -165,7 +173,8 @@ void AvailabilityInference::applyInferredAvailableAttrs(
 
 /// Returns the decl that should be considered the parent decl of the given decl
 /// when looking for inherited availability annotations.
-static Decl *parentDeclForAvailability(const Decl *D) {
+const Decl *
+AvailabilityInference::parentDeclForInferredAvailability(const Decl *D) {
   if (auto *AD = dyn_cast<AccessorDecl>(D))
     return AD->getStorage();
 
@@ -230,7 +239,8 @@ SemanticAvailableRangeAttrRequest::evaluate(Evaluator &evaluator,
           decl, decl->getASTContext()))
     return std::make_pair(attr, decl);
 
-  if (auto *parent = parentDeclForAvailability(decl))
+  if (auto *parent =
+          AvailabilityInference::parentDeclForInferredAvailability(decl))
     return parent->getSemanticAvailableRangeAttr();
 
   return None;
@@ -262,7 +272,8 @@ SemanticUnavailableAttrRequest::evaluate(Evaluator &evaluator,
   if (auto attr = decl->getAttrs().getUnavailable(decl->getASTContext()))
     return std::make_pair(attr, decl);
 
-  if (auto *parent = parentDeclForAvailability(decl))
+  if (auto *parent =
+          AvailabilityInference::parentDeclForInferredAvailability(decl))
     return parent->getSemanticUnavailableAttr();
 
   return None;

lib/AST/Decl.cpp

@@ -477,8 +477,12 @@ unsigned Decl::getAttachedMacroDiscriminator(
 }
 
 const Decl *Decl::getInnermostDeclWithAvailability() const {
-  if (auto attrAndDecl = getSemanticAvailableRangeAttr())
-    return attrAndDecl.value().second;
+  if (getAttrs().hasAttribute<AvailableAttr>())
+    return this;
+
+  if (auto parent =
+          AvailabilityInference::parentDeclForInferredAvailability(this))
+    return parent->getInnermostDeclWithAvailability();
 
   return nullptr;
 }

test/Concurrency/concurrency_availability.swift

@@ -3,6 +3,8 @@
 // RUN: %target-swift-frontend -parse-stdlib -target x86_64-apple-macosx12 -typecheck %s -DTARGET_MACOS_12
 // REQUIRES: OS=macosx
 
+import _Concurrency
+
 func f() async { } // expected-error{{concurrency is only available in}}
 // expected-note@-1{{add @available}}
 
@@ -13,19 +15,41 @@ actor A { }  // expected-error{{concurrency is only available in}}
 public func swift_deletedAsyncMethodError() async {
 }
 
-// Ensure that our synthesis of the actor's unownedExecutor does not cause
-// availability errors.
 @available(macOS 12.0, *)
 struct S {
-  actor A {
+  // Ensure that our synthesis of the actor's unownedExecutor does not cause
+  // availability errors.
+  actor NestedActor {
+  }
+
+  // The synthesized unownedExecutor inside this actor should inherit the
+  // un-availability of UnavailableActor.
+  @available(macOS, unavailable)
+  actor UnavailableActor {
   }
 }
 
+#if TARGET_MACOS_12
 // The synthesized unownedExecutor inside this extension on S should inherit
 // availability from S to avoid availability errors.
-#if TARGET_MACOS_12
 extension S {
-  actor A2 {
+  actor ExtensionNestedActor {
   }
 }
 #endif
+
+// Make sure that the conformances to Actor are actually being synthesized
+// since otherwise this test isn't actually testing what it is designed to test.
+@available(macOS 10.15, *)
+func takesExecutor(_ e: UnownedSerialExecutor) { }
+
+@available(macOS 12.0, *)
+func testNestedActorConformance(_ a: S.NestedActor) {
+  takesExecutor(a.unownedExecutor)
+}
+
+#if TARGET_MACOS_12
+func testExtensionNestedActorConformance(_ a: S.ExtensionNestedActor) {
+  takesExecutor(a.unownedExecutor)
+}
+#endif

test/ModuleInterface/actor_availability.swift

@@ -0,0 +1,68 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-emit-module-interface(%t/Library.swiftinterface) %s -module-name Library -target %target-swift-abi-5.3-triple
+// RUN: %target-swift-typecheck-module-from-interface(%t/Library.swiftinterface) -module-name Library
+// RUN: %FileCheck %s < %t/Library.swiftinterface
+
+// REQUIRES: VENDOR=apple
+
+// CHECK: #if compiler(>=5.3) && $Actors
+// CHECK-NEXT: public actor ActorWithImplicitAvailability {
+public actor ActorWithImplicitAvailability {
+  // CHECK: @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *)
+  // CHECK-NEXT: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
+  // CHECK-NEXT:   get
+  // CHECK-NEXT: }
+}
+// CHECK: #endif
+
+// CHECK: #if compiler(>=5.3) && $Actors
+// CHECK-NEXT: @available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *)
+// CHECK-NEXT: public actor ActorWithExplicitAvailability {
+@available(SwiftStdlib 5.2, *)
+public actor ActorWithExplicitAvailability {
+  // CHECK: @available(iOS 13.4, tvOS 13.4, watchOS 6.2, macOS 10.15.4, *)
+  // CHECK-NEXT: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
+  // CHECK-NEXT:   get
+  // CHECK-NEXT: }
+}
+// CHECK: #endif
+
+// CHECK: #if compiler(>=5.3) && $Actors
+// CHECK-NEXT: @_hasMissingDesignatedInitializers @available(macOS, unavailable)
+// CHECK-NEXT: public actor UnavailableActor {
+@available(macOS, unavailable)
+public actor UnavailableActor {
+  // CHECK: @available(iOS 13.0, tvOS 13.0, watchOS 6.0, *)
+  // CHECK-NEXT: @available(macOS, unavailable)
+  // CHECK-NEXT: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
+  // CHECK-NEXT:   get
+  // CHECK-NEXT: }
+}
+// CHECK: #endif
+
+// CHECK: @available(macOS 10.15.4, iOS 13.4, watchOS 6.2, tvOS 13.4, *)
+// CHECK-NEXT: public enum Enum {
+@available(SwiftStdlib 5.2, *)
+public enum Enum {
+  // CHECK:   #if compiler(>=5.3) && $Actors
+  // CHECK-NEXT: @_hasMissingDesignatedInitializers public actor NestedActor {
+  public actor NestedActor {
+    // CHECK: @available(iOS 13.4, tvOS 13.4, watchOS 6.2, macOS 10.15.4, *)
+    // CHECK-NEXT: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
+    // CHECK-NEXT:   get
+    // CHECK-NEXT: }
+  }
+  // CHECK: #endif
+}
+
+// CHECK: extension Library.Enum {
+extension Enum {
+  // CHECK: #if compiler(>=5.3) && $Actors
+  // CHECK-NEXT: @_hasMissingDesignatedInitializers public actor ExtensionNestedActor {
+  public actor ExtensionNestedActor {
+    // CHECK: @available(iOS 13.4, tvOS 13.4, watchOS 6.2, macOS 10.15.4, *)
+    // CHECK-NEXT: @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {
+    // CHECK-NEXT:   get
+    // CHECK-NEXT: }
+  }
+}