AST: Ignore availability attrs for app extension platforms in some queries.

When determining whether a declaration should be considered unavailable at
runtime, ignore `@available` attributes for application extension platforms but
continue searching for other `@available` attributes that might still make the
declaration unavailable. This ensures corner cases like these are handled:

```
// Dubious, but allowed
@available(macOS, unavailable)
@available(macOSApplicationExtension, unavailable)
public func doublyUnavailableOnMacOSFunc() {}

// Expresses an uncommon, but valid constraint
@available(macCatalyst, unavailable)
@available(iOSApplicationExtension, unavailable)
public func confusingDiamondAvailabilityInheritanceFunc() {}
```

Author: tshortli

include/swift/AST/Attr.h

@@ -2655,7 +2655,8 @@ class DeclAttributes {
   /// Finds the most-specific platform-specific attribute that is
   /// active for the current platform.
   const AvailableAttr *
-  findMostSpecificActivePlatform(const ASTContext &ctx) const;
+  findMostSpecificActivePlatform(const ASTContext &ctx,
+                                 bool ignoreAppExtensions = false) const;
 
   /// Returns the first @available attribute that indicates
   /// a declaration is unavailable, or the first one that indicates it's
@@ -2664,7 +2665,8 @@ class DeclAttributes {
 
   /// Returns the first @available attribute that indicates
   /// a declaration is unavailable, or null otherwise.
-  const AvailableAttr *getUnavailable(const ASTContext &ctx) const;
+  const AvailableAttr *getUnavailable(const ASTContext &ctx,
+                                      bool ignoreAppExtensions = false) const;
 
   /// Returns the first @available attribute that indicates
   /// a declaration is deprecated on all deployment targets, or null otherwise.

include/swift/AST/Decl.h

@@ -1286,7 +1286,8 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   getSemanticAvailableRangeAttr() const;
 
   /// Retrieve the @available attribute that makes this declaration unavailable,
-  /// if any.
+  /// if any. If \p ignoreAppExtensions is true then attributes for app
+  /// extension platforms are ignored.
   ///
   /// This attribute may come from an enclosing decl since availability is
   /// inherited. The second member of the returned pair is the decl that owns
@@ -1295,7 +1296,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// Note that this notion of unavailability is broader than that which is
   /// checked by \c AvailableAttr::isUnavailable.
   llvm::Optional<std::pair<const AvailableAttr *, const Decl *>>
-  getSemanticUnavailableAttr() const;
+  getSemanticUnavailableAttr(bool ignoreAppExtensions = false) const;
 
   /// Returns true if this declaration should be considered available during
   /// SIL/IR lowering. A declaration would not be available during lowering if,

include/swift/AST/TypeCheckRequests.h

@@ -3985,16 +3985,18 @@ class SemanticAvailableRangeAttrRequest
 
 class SemanticUnavailableAttrRequest
     : public SimpleRequest<SemanticUnavailableAttrRequest,
-                           llvm::Optional<AvailableAttrDeclPair>(const Decl *),
+                           llvm::Optional<AvailableAttrDeclPair>(
+                               const Decl *decl, bool ignoreAppExtensions),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  llvm::Optional<AvailableAttrDeclPair> evaluate(Evaluator &evaluator,
-                                                 const Decl *decl) const;
+  llvm::Optional<AvailableAttrDeclPair>
+  evaluate(Evaluator &evaluator, const Decl *decl,
+           bool ignoreAppExtensions) const;
 
 public:
   bool isCached() const { return true; }

lib/AST/Attr.cpp

@@ -337,7 +337,8 @@ DeclAttributes::isUnavailableInSwiftVersion(
 }
 
 const AvailableAttr *
-DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx) const{
+DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx,
+                                               bool ignoreAppExtensions) const {
   const AvailableAttr *bestAttr = nullptr;
 
   for (auto attr : *this) {
@@ -354,6 +355,9 @@ DeclAttributes::findMostSpecificActivePlatform(const ASTContext &ctx) const{
     if (!avAttr->isActivePlatform(ctx))
       continue;
 
+    if (ignoreAppExtensions && isApplicationExtensionPlatform(avAttr->Platform))
+      continue;
+
     // We have an attribute that is active for the platform, but
     // is it more specific than our current best?
     if (!bestAttr || inheritsAvailabilityFromPlatform(avAttr->Platform,
@@ -407,10 +411,12 @@ DeclAttributes::getPotentiallyUnavailable(const ASTContext &ctx) const {
   return potential;
 }
 
-const AvailableAttr *DeclAttributes::getUnavailable(
-                          const ASTContext &ctx) const {
+const AvailableAttr *
+DeclAttributes::getUnavailable(const ASTContext &ctx,
+                               bool ignoreAppExtensions) const {
   const AvailableAttr *conditional = nullptr;
-  const AvailableAttr *bestActive = findMostSpecificActivePlatform(ctx);
+  const AvailableAttr *bestActive =
+      findMostSpecificActivePlatform(ctx, ignoreAppExtensions);
 
   for (auto Attr : *this)
     if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
@@ -429,6 +435,10 @@ const AvailableAttr *DeclAttributes::getUnavailable(
           !AvAttr->isPackageDescriptionVersionSpecific())
         continue;
 
+      if (ignoreAppExtensions &&
+          isApplicationExtensionPlatform(AvAttr->Platform))
+        continue;
+
       // Unconditional unavailable.
       if (AvAttr->isUnconditionallyUnavailable())
         return AvAttr;

lib/AST/Availability.cpp

@@ -302,31 +302,35 @@ bool Decl::isAvailableAsSPI() const {
 }
 
 llvm::Optional<AvailableAttrDeclPair>
-SemanticUnavailableAttrRequest::evaluate(Evaluator &evaluator,
-                                         const Decl *decl) const {
+SemanticUnavailableAttrRequest::evaluate(Evaluator &evaluator, const Decl *decl,
+                                         bool ignoreAppExtensions) const {
   // Directly marked unavailable.
-  if (auto attr = decl->getAttrs().getUnavailable(decl->getASTContext()))
+  if (auto attr = decl->getAttrs().getUnavailable(decl->getASTContext(),
+                                                  ignoreAppExtensions))
     return std::make_pair(attr, decl);
 
   if (auto *parent =
           AvailabilityInference::parentDeclForInferredAvailability(decl))
-    return parent->getSemanticUnavailableAttr();
+    return parent->getSemanticUnavailableAttr(ignoreAppExtensions);
 
   return llvm::None;
 }
 
-llvm::Optional<AvailableAttrDeclPair> Decl::getSemanticUnavailableAttr() const {
+llvm::Optional<AvailableAttrDeclPair>
+Decl::getSemanticUnavailableAttr(bool ignoreAppExtensions) const {
   auto &eval = getASTContext().evaluator;
-  return evaluateOrDefault(eval, SemanticUnavailableAttrRequest{this},
-                           llvm::None);
+  return evaluateOrDefault(
+      eval, SemanticUnavailableAttrRequest{this, ignoreAppExtensions},
+      llvm::None);
 }
 
 static bool shouldStubOrSkipUnavailableDecl(const Decl *D) {
   // Don't trust unavailability on declarations from clang modules.
   if (isa<ClangModuleUnit>(D->getDeclContext()->getModuleScopeContext()))
     return false;
 
-  auto unavailableAttrAndDecl = D->getSemanticUnavailableAttr();
+  auto unavailableAttrAndDecl =
+      D->getSemanticUnavailableAttr(/*ignoreAppExtensions=*/true);
   if (!unavailableAttrAndDecl)
     return false;
 
@@ -338,11 +342,6 @@ static bool shouldStubOrSkipUnavailableDecl(const Decl *D) {
   if (!unavailableAttr->isUnconditionallyUnavailable())
     return false;
 
-  // If the decl is only unavailable to app extensions it still may need to be
-  // present at runtime for non-extension processes.
-  if (isApplicationExtensionPlatform(unavailableAttr->Platform))
-    return false;
-
   return true;
 }
 

test/SILGen/unavailable_decl_optimization_stub_macos.swift

@@ -35,6 +35,15 @@ public func unavailableOnMacOSFunc() {}
 @available(macOSApplicationExtension, unavailable)
 public func unavailableOnMacOSExtensionFunc() {}
 
+// CHECK-LABEL:     sil{{.*}}@$s4Test021unavailableOnMacOSAndD15OSExtensionFuncyyF
+// CHECK-SWIFT5_8:    [[FNREF:%.*]] = function_ref @$ss36_diagnoseUnavailableCodeReached_aeics5NeverOyF : $@convention(thin) () -> Never
+// CHECK-SWIFT5_9:    [[FNREF:%.*]] = function_ref @$ss31_diagnoseUnavailableCodeReacheds5NeverOyF : $@convention(thin) () -> Never
+// CHECK-NEXT:        [[APPLY:%.*]] = apply [[FNREF]]()
+// CHECK:           } // end sil function '$s4Test021unavailableOnMacOSAndD15OSExtensionFuncyyF'
+@available(macOS, unavailable)
+@available(macOSApplicationExtension, unavailable) // FIXME: Seems like this should be diagnosed as redundant
+public func unavailableOnMacOSAndMacOSExtensionFunc() {}
+
 // CHECK-LABEL:     sil{{.*}}@$s4Test20unavailableOniOSFuncyyF
 // CHECK-NOT:         function_ref @$ss36_diagnoseUnavailableCodeReached{{.*}} : $@convention(thin) () -> Never
 // CHECK:           } // end sil function '$s4Test20unavailableOniOSFuncyyF'