Sema: Fix isExported() for extension decls in order to correct availability diagnostics when -target-min-inlining-version min is specified.

Previously, an extension decl was always considered exported (externally visible to module clients) as long as it extended an exported type. Extensions need to either contain some externally visible member (e.g. a public method) or implement a conformance to a public protcol, though, to actually be exported. Without this fix, the compiler incorrectly requires internal extensions to types that are always available at runtime to have declared availability which would be a nuisance for library authors.

As part of testing this change, I expanded the attr_inlinable_available.swift test case significantly and that prompted me to scrap the copy of the test specific to macCatalyst as it seemed like needing to keep the two tests in sync was going to be a liability going forward. I replaced the deleted test with a couple of more targeted tests that use `-dump-type-refinement-contexts` to verify the effect of `-target-min-inlining-version min` on the root refinement context. Again a macCatalyst version of the test is required because we don't have bots that are configured to make the macCatalyst runtime the "target" OS.

Resolves rdar://91382040

Author: tshortli

lib/Sema/TypeCheckAvailability.cpp

@@ -78,6 +78,33 @@ bool swift::isExported(const ValueDecl *VD) {
   return false;
 }
 
+bool swift::isExported(const ExtensionDecl *ED) {
+  // An extension can only be exported if it extends an exported type.
+  if (auto *NTD = ED->getExtendedNominal()) {
+    if (!isExported(NTD))
+      return false;
+  }
+
+  // If there are any exported members then the extension is exported.
+  for (const Decl *D : ED->getMembers()) {
+    if (isExported(D))
+      return true;
+  }
+
+  // If the extension declares a conformance to a public protocol then the
+  // extension is exported.
+  auto protocols = ED->getLocalProtocols(ConformanceLookupKind::OnlyExplicit);
+  for (const ProtocolDecl *PD : protocols) {
+    AccessScope scope =
+      PD->getFormalAccessScope(/*useDC*/nullptr,
+                               /*treatUsableFromInlineAsPublic*/true);
+    if (scope.isPublic())
+      return true;
+  }
+
+  return false;
+}
+
 bool swift::isExported(const Decl *D) {
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
     return isExported(VD);
@@ -91,10 +118,7 @@ bool swift::isExported(const Decl *D) {
     return false;
   }
   if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
-    if (auto *NTD = ED->getExtendedNominal())
-      return isExported(NTD);
-
-    return false;
+    return isExported(ED);
   }
 
   return true;

lib/Sema/TypeCheckAvailability.h

@@ -183,9 +183,10 @@ class ExportContext {
   Optional<ExportabilityReason> getExportabilityReason() const;
 };
 
-/// Check if a public declaration is part of a module's API; that is, this
-/// will return false if the declaration is @_spi or @_implementationOnly.
+/// Check if a declaration is exported as part of a module's external interface.
+/// This includes public and @usableFromInline decls.
 bool isExported(const ValueDecl *VD);
+bool isExported(const ExtensionDecl *ED);
 bool isExported(const Decl *D);
 
 /// Diagnose uses of unavailable declarations in expressions.

test/Sema/availability_refinement_contexts_target_min_inlining.swift

@@ -0,0 +1,18 @@
+// RUN: %target-swift-frontend -swift-version 5 -enable-library-evolution -target %target-next-stable-abi-triple -typecheck -dump-type-refinement-contexts -target-min-inlining-version min %s > %t.dump 2>&1
+// RUN: %FileCheck --strict-whitespace --check-prefix CHECK-%target-os %s < %t.dump
+
+// REQUIRES: swift_stable_abi
+
+// Verify that -target-min-inlining-version min implies the correct OS version
+// for the target OS.
+
+// CHECK-macosx: {{^}}(root versions=[10.10.0,+Inf)
+// CHECK-ios: {{^}}(root versions=[8.0,+Inf)
+// CHECK-tvos: {{^}}(root versions=[9.0,+Inf)
+// CHECK-watchos: {{^}}(root versions=[2.0,+Inf)
+
+// CHECK-macosx-NEXT: {{^}}  (resilience_boundary versions=[10.15.0,+Inf) decl=foo()
+// CHECK-ios-NEXT: {{^}}  (resilience_boundary versions=[13.0.0,+Inf) decl=foo()
+// CHECK-tvos-NEXT: {{^}}  (resilience_boundary versions=[13.0.0,+Inf) decl=foo()
+// CHECK-watchos-NEXT: {{^}}  (resilience_boundary versions=[6.0.0,+Inf) decl=foo()
+func foo() {}

test/Sema/availability_refinement_contexts_target_min_inlining_maccatalyst.swift

@@ -0,0 +1,15 @@
+// This test is the same as availability_refinement_contexts_target_min_inlining.swift
+// but with a different run invocation to specifically test macCatalyst because
+// currently there are no bots that run the tests with macCatalyst as the
+// target OS.
+
+// RUN: %target-swift-frontend -swift-version 5 -enable-library-evolution -target %target-cpu-apple-ios14.4-macabi -typecheck -dump-type-refinement-contexts -target-min-inlining-version min %s > %t.dump 2>&1
+// RUN: %FileCheck --strict-whitespace %s < %t.dump
+
+// REQUIRES: maccatalyst_support
+
+// Verify that -target-min-inlining-version min implies 13.1 on macCatalyst.
+
+// CHECK: {{^}}(root versions=[13.1,+Inf)
+// CHECK-NEXT: {{^}}  (resilience_boundary versions=[14.4.0,+Inf) decl=foo()
+func foo() {}

test/attr/attr_inlinable_available.swift

@@ -71,11 +71,42 @@ public struct AfterDeploymentTarget {
   @usableFromInline internal init() {}
 }
 
+// MARK: - Internal functions
 
+//
+// Both the signature and the body of internal functions should be typechecked
+// using the minimum deployment target.
+//
+
+internal func internalFn( // expected-note 3 {{add @available attribute to enclosing global function}}
+  _: NoAvailable,
+  _: BeforeInliningTarget,
+  _: AtInliningTarget,
+  _: BetweenTargets,
+  _: AtDeploymentTarget,
+  _: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
+) {
+  defer {
+    _ = AtDeploymentTarget()
+    _ = AfterDeploymentTarget() // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
+  }
+  _ = NoAvailable()
+  _ = BeforeInliningTarget()
+  _ = AtInliningTarget()
+  _ = BetweenTargets()
+  _ = AtDeploymentTarget()
+  _ = AfterDeploymentTarget() // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add 'if #available'}}
+
+  if #available(macOS 11, iOS 14, tvOS 14, watchOS 7, *) {
+    _ = AfterDeploymentTarget()
+  }
+}
+
+// MARK: - Resilient functions
 
 //
-// Uses in resilient functions are based on the minimum deployment target
-// (i.e. the -target).
+// The body of a resilient function is typechecked using the minimum deployment
+// but the function's signature should be checked with the inlining target.
 //
 
 public func deployedUseNoAvailable( // expected-note 5 {{add @available attribute}}
@@ -224,9 +255,11 @@ public func deployedUseAfterDeploymentTarget(
 }
 
 
+// MARK: - @inlinable functions
 
 //
-// Uses in inlinable functions are based on the minimum inlining target
+// Both the bodies and signatures of inlinable functions need to be typechecked
+// using the minimum inlining target.
 //
 
 @inlinable public func inlinedUseNoAvailable( // expected-note 8 {{add @available attribute}}
@@ -395,15 +428,8 @@ public func deployedUseAfterDeploymentTarget(
   _ = AfterDeploymentTarget()
 }
 
-//
-// Edge cases.
-//
-
-// Internal functions should use the minimum deployment target.
 
-internal func fn() {
-  _ = AtDeploymentTarget()
-}
+// MARK: - @_alwaysEmitIntoClient functions
 
 // @_alwaysEmitIntoClient acts like @inlinable.
 
@@ -437,6 +463,9 @@ internal func fn() {
   }
 }
 
+
+// MARK: - @_backDeploy functions
+
 // @_backDeploy acts like @inlinable.
 
 @available(macOS 10.10, iOS 8.0, tvOS 9.0, watchOS 2.0, *)
@@ -471,6 +500,9 @@ public func backDeployedToInliningTarget(
   }
 }
 
+
+// MARK: - Default arguments
+
 // Default arguments act like @inlinable.
 
 public func defaultArgsUseNoAvailable( // expected-note 3 {{add @available attribute}}
@@ -551,6 +583,116 @@ internal struct InternalStruct { // expected-note {{add @available attribute}}
   var fInternal: AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
 }
 
+
+// MARK: - Extensions
+
+//
+// Extensions are externally visible if they extend a public type and (1) have
+// public members or (2) declare a conformance to a public protocol. Externally
+// visible extensions should be typechecked with the inlining target.
+//
+
+// OK, NoAvailable is always available, both internally and externally.
+extension NoAvailable {}
+extension NoAvailable {
+  public func publicFunc1() {}
+}
+
+// OK, no public members and BetweenTargets is always available internally.
+extension BetweenTargets {}
+
+// OK, no public members and BetweenTargets is always available internally.
+extension BetweenTargets {
+  internal func internalFunc1() {}
+  private func privateFunc1() {}
+  fileprivate func fileprivateFunc1() {}
+}
+
+// expected-error@+1 {{'BetweenTargets' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension BetweenTargets {
+  public func publicFunc1() {}
+}
+
+// expected-error@+1 {{'BetweenTargets' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension BetweenTargets {
+  @usableFromInline
+  internal func usableFromInlineFunc1() {}
+}
+
+// expected-error@+1 {{'BetweenTargets' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension BetweenTargets {
+  internal func internalFunc2() {}
+  private func privateFunc2() {}
+  fileprivate func fileprivateFunc2() {}
+  public func publicFunc2() {}
+}
+
+// Same availability as BetweenTargets but internal instead of public.
+@available(macOS 10.14.5, iOS 12.3, tvOS 12.3, watchOS 5.3, *)
+internal struct BetweenTargetsInternal {}
+
+// OK, extensions on internal types are never visible externally.
+extension BetweenTargetsInternal {}
+extension BetweenTargetsInternal {
+  public func publicFunc() {}
+}
+
+// expected-error@+1 {{'AfterDeploymentTarget' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension AfterDeploymentTarget {}
+
+// expected-error@+1 {{'AfterDeploymentTarget' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension AfterDeploymentTarget {
+  internal func internalFunc1() {}
+  private func privateFunc1() {}
+  fileprivate func fileprivateFunc1() {}
+}
+
+// expected-error@+1 {{'AfterDeploymentTarget' is only available in}} expected-note@+1 {{add @available attribute to enclosing extension}}
+extension AfterDeploymentTarget {
+  public func publicFunc1() {}
+}
+
+
+// MARK: Protocol conformances
+
+internal protocol InternalProto {}
+
+extension NoAvailable: InternalProto {}
+extension BeforeInliningTarget: InternalProto {}
+extension AtInliningTarget: InternalProto {}
+extension BetweenTargets: InternalProto {}
+extension AtDeploymentTarget: InternalProto {}
+extension AfterDeploymentTarget: InternalProto {} // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add @available attribute to enclosing extension}}
+
+public protocol PublicProto {}
+
+extension NoAvailable: PublicProto {}
+extension BeforeInliningTarget: PublicProto {}
+extension AtInliningTarget: PublicProto {}
+extension BetweenTargets: PublicProto {} // expected-error {{'BetweenTargets' is only available in}} expected-note {{add @available attribute to enclosing extension}}
+extension AtDeploymentTarget: PublicProto {} // expected-error {{'AtDeploymentTarget' is only available in}} expected-note {{add @available attribute to enclosing extension}}
+extension AfterDeploymentTarget: PublicProto {} // expected-error {{'AfterDeploymentTarget' is only available in}} expected-note {{add @available attribute to enclosing extension}}
+
+
+// MARK: - Type aliases
+
+public typealias PublicNoAvailableAlias = NoAvailable
+public typealias PublicBeforeInliningTargetAlias = BeforeInliningTarget
+public typealias PublicAtInliningTargetAlias = AtInliningTarget
+public typealias PublicBetweenTargetsAlias = BetweenTargets // expected-error {{'BetweenTargets' is only available in}}
+public typealias PublicAtDeploymentTargetAlias = AtDeploymentTarget // expected-error {{'AtDeploymentTarget' is only available in}}
+public typealias PublicAfterDeploymentTargetAlias = AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
+
+typealias InternalNoAvailableAlias = NoAvailable
+typealias InternalBeforeInliningTargetAlias = BeforeInliningTarget
+typealias InternalAtInliningTargetAlias = AtInliningTarget
+typealias InternalBetweenTargetsAlias = BetweenTargets
+typealias InternalAtDeploymentTargetAlias = AtDeploymentTarget
+typealias InternalAfterDeploymentTargetAlias = AfterDeploymentTarget // expected-error {{'AfterDeploymentTarget' is only available in}}
+
+
+// MARK: - Top-level code
+
 // Top-level code, if somehow present in a resilient module, is treated like
 // a non-inlinable function.
 defer {