[5.7] Fix issues blocking enablement of -target-min-inlining-version min (swiftlang#59176)

Cherry-pick and squash of the following PRs to release/5.7:

swiftlang#42585
swiftlang#58417
swiftlang#58654
swiftlang#58680
swiftlang#58707
swiftlang#58870
swiftlang#58963
swiftlang#59040
swiftlang#59065

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

Resolves rdar://91382040

* Sema: Avoid diagnosing potential unavailability of type components (extension nominal type, superclass, etc.) on declarations that are explicitly unavailable.

Resolves rdar://92179327

* Sema: Downgrade diagnostics about potential unavailability of the extended type in an extension declaration when the following conditions are met:

1. The extension is missing explicit availability.
2. The required availability is before the deployment target.

Resolves rdar://92621567

* NFC: Expand `-target-min-inlining-versiong` tests to cover a number of corner cases:

- unavailable declarations and unavailable containers
- SPI declarations and spi containers
- property initializer expressions
- property wrappers

* Sema: When computing potential unavailability of a decl, first check whether the decl is explicitly unavailable and the context is also unavailable. If those conditions are met, treat the decl as if it were always available since unavailable code is allowed to reference unavailable decls.

Resolves rdar://92551870

* Sema: Use the deployment target when checking availability for SPI and unavailable API declarations with `-target-min-inlining-version min` specified. There's not much benefit to more accurate enforcement of availability in these decls since API clients can't use them and there's a lot of existing code that would be needlessly diagnosed without these exceptions.

Resolves rdar://92716633

* Sema: Teach the compiler to refine `VarDecl` initializer expressions using the deployment target when the init would not be exposed to module clients. Without this, the initializers of public properties in API modules could be misdiagnosed as potentially unavailable to clients of the module, even though the expression will only ever execute on the deployment target or higher.

Resolves rdar://92713589

* Tests: Update `attr_inlinable_available.swift` to require macOS and remove the OS versions for other platforms from availability attributes.

* Tests: Add test cases for potential unavailability in class inheritance when  is specified.

* Sema: Reword diagnostics about potentially unavailable decls to improve clarity for authors of API libraries. When decls are diagnosed as potentially unavailable on an OS earlier than the deployment target, the message will now indicate that the issue would be faced by clients of the module.

Resolves rdar://93466875

* Sema: Use the availability of the extended nominal as a floor for the availability of extensions. The primary motivation for this change is to reduce unnecessary availability diagnostics for API library authors. Many API libraries contain existing extension decls that lack declared availability where the extension introduces additional members to the extended type in the same release that the extended type was declared. Others contain extensions where the extension itself does not have declared availability but each of the members do. In both cases, the code is safe as written so the extra diagnostics would be a nuisance.

Resolves rdar://93630782

* Sema: Downgrade diagnostics about inheritance from a less available type when `-target-min-inlining-version min` is specified.

As a concession to source compatibility for API libraries, downgrade diagnostics about inheritance from a less available type when the following conditions are met:
1. The inherited type is only potentially unavailable before the deployment target.
2. The inheriting type is `@usableFromInline`.

Resolves rdar://92747826

Author: tshortli

include/swift/AST/Availability.h

@@ -93,6 +93,18 @@ class VersionRange {
     return getLowerEndpoint() >= Other.getLowerEndpoint();
   }
 
+  // Returns true if all the versions in the Other range are versions in this
+  // range and the ranges are not equal.
+  bool isSupersetOf(const VersionRange &Other) const {
+    if (isEmpty() || Other.isAll())
+      return false;
+
+    if (isAll() || Other.isEmpty())
+      return true;
+
+    return getLowerEndpoint() < Other.getLowerEndpoint();
+  }
+
   /// Mutates this range to be a best-effort underapproximation of
   /// the intersection of itself and Other. This is the
   /// meet operation (greatest lower bound) in the version range lattice.
@@ -244,10 +256,17 @@ class AvailabilityContext {
   /// Returns true if \p other makes stronger guarantees than this context.
   ///
   /// That is, `a.isContainedIn(b)` implies `a.union(b) == b`.
-  bool isContainedIn(AvailabilityContext other) const {
+  bool isContainedIn(const AvailabilityContext &other) const {
     return OSVersion.isContainedIn(other.OSVersion);
   }
 
+  /// Returns true if \p other is a strict subset of this context.
+  ///
+  /// That is, `a.isSupersetOf(b)` implies `a != b` and `a.union(b) == a`.
+  bool isSupersetOf(const AvailabilityContext &other) const {
+    return OSVersion.isSupersetOf(other.OSVersion);
+  }
+
   /// Returns true if this context has constraints that make it impossible to
   /// actually occur.
   ///
@@ -272,7 +291,7 @@ class AvailabilityContext {
   ///
   /// As an example, this is used when figuring out the required availability
   /// for a type that references multiple nominal decls.
-  void intersectWith(AvailabilityContext other) {
+  void intersectWith(const AvailabilityContext &other) {
     OSVersion.intersectWith(other.getOSVersion());
   }
 
@@ -283,7 +302,7 @@ class AvailabilityContext {
   /// treating some invalid deployment environments as available.
   ///
   /// As an example, this is used for the true branch of `#available`.
-  void constrainWith(AvailabilityContext other) {
+  void constrainWith(const AvailabilityContext &other) {
     OSVersion.constrainWith(other.getOSVersion());
   }
 
@@ -295,7 +314,7 @@ class AvailabilityContext {
   ///
   /// As an example, this is used for the else branch of a conditional with
   /// multiple `#available` checks.
-  void unionWith(AvailabilityContext other) {
+  void unionWith(const AvailabilityContext &other) {
     OSVersion.unionWith(other.getOSVersion());
   }
 

include/swift/AST/DiagnosticsSema.def

@@ -5582,6 +5582,16 @@ ERROR(availability_decl_only_version_newer, none,
       "%0 is only available in %1 %2 or newer",
       (DeclName, StringRef, llvm::VersionTuple))
 
+ERROR(availability_decl_only_version_newer_for_clients, none,
+      "%0 is only available in %1 %2 or newer; clients of %3 may have a lower"
+      " deployment target",
+      (DeclName, StringRef, llvm::VersionTuple, ModuleDecl *))
+
+WARNING(availability_decl_only_version_newer_for_clients_warn, none,
+        "%0 is only available in %1 %2 or newer; clients of %3 may have a lower"
+        " deployment target",
+        (DeclName, StringRef, llvm::VersionTuple, ModuleDecl *))
+
 ERROR(availability_opaque_types_only_version_newer, none,
       "'some' return types are only available in %0 %1 or newer",
       (StringRef, llvm::VersionTuple))

include/swift/AST/TypeRefinementContext.h

@@ -54,15 +54,19 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
     /// The root refinement context.
     Root,
 
-    /// The context was introduced by a declaration (e.g., the body of a
-    /// function declaration or the contents of a class declaration).
+    /// The context was introduced by a declaration with an explicit
+    /// availability attribute. The context contains both the signature and the
+    /// body of the declaration.
     Decl,
 
-    /// The context was introduced by a resilience boundary; that is, we are in
-    /// a module with library evolution enabled and the parent context's
-    /// contents can be visible to the module's clients, but this context's
-    /// contents are not.
-    ResilienceBoundary,
+    /// The context was introduced implicitly by a declaration. The context may
+    /// cover the entire declaration or it may cover a subset of it. For
+    /// example, a public, non-inlinable function declaration in an API module
+    /// will have at least two associated contexts: one for the entire
+    /// declaration at the declared availability of the API and a nested
+    /// implicit context for the body of the function, which will always run at
+    /// the deployment target of the library.
+    DeclImplicit,
 
     /// The context was introduced for the Then branch of an IfStmt.
     IfStmtThenBranch,
@@ -132,7 +136,7 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
 
     Decl *getAsDecl() const {
       assert(IntroReason == Reason::Decl ||
-             IntroReason == Reason::ResilienceBoundary);
+             IntroReason == Reason::DeclImplicit);
       return D;
     }
 
@@ -164,8 +168,8 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
 
   SourceRange SrcRange;
 
-  /// A canonical availiability info for this context, computed top-down from the root
-  /// context (compilation deployment target).
+  /// A canonical availability info for this context, computed top-down from the
+  /// root context.
   AvailabilityContext AvailabilityInfo;
 
   /// If this context was annotated with an availability attribute, this property captures that.
@@ -195,10 +199,8 @@ class TypeRefinementContext : public ASTAllocated<TypeRefinementContext> {
 
   /// Create a refinement context for the given declaration.
   static TypeRefinementContext *
-  createForResilienceBoundary(ASTContext &Ctx, Decl *D,
-                              TypeRefinementContext *Parent,
-                              const AvailabilityContext &Info,
-                              SourceRange SrcRange);
+  createForDeclImplicit(ASTContext &Ctx, Decl *D, TypeRefinementContext *Parent,
+                        const AvailabilityContext &Info, SourceRange SrcRange);
 
   /// Create a refinement context for the Then branch of the given IfStmt.
   static TypeRefinementContext *

lib/AST/TypeRefinementContext.cpp

@@ -64,18 +64,14 @@ TypeRefinementContext::createForDecl(ASTContext &Ctx, Decl *D,
       TypeRefinementContext(Ctx, D, Parent, SrcRange, Info, ExplicitInfo);
 }
 
-TypeRefinementContext *
-TypeRefinementContext::createForResilienceBoundary(ASTContext &Ctx, Decl *D,
-                                TypeRefinementContext *Parent,
-                                const AvailabilityContext &Info,
-                                SourceRange SrcRange) {
+TypeRefinementContext *TypeRefinementContext::createForDeclImplicit(
+    ASTContext &Ctx, Decl *D, TypeRefinementContext *Parent,
+    const AvailabilityContext &Info, SourceRange SrcRange) {
   assert(D);
   assert(Parent);
-  return new (Ctx)
-      TypeRefinementContext(Ctx, IntroNode(D, Reason::ResilienceBoundary),
-                            Parent, SrcRange, Info,
-                            AvailabilityContext::alwaysAvailable());
-
+  return new (Ctx) TypeRefinementContext(
+      Ctx, IntroNode(D, Reason::DeclImplicit), Parent, SrcRange, Info,
+      AvailabilityContext::alwaysAvailable());
 }
 
 TypeRefinementContext *
@@ -184,7 +180,7 @@ void TypeRefinementContext::dump(raw_ostream &OS, SourceManager &SrcMgr) const {
 SourceLoc TypeRefinementContext::getIntroductionLoc() const {
   switch (getReason()) {
   case Reason::Decl:
-  case Reason::ResilienceBoundary:
+  case Reason::DeclImplicit:
     return Node.getAsDecl()->getLoc();
 
   case Reason::IfStmtThenBranch:
@@ -298,7 +294,7 @@ TypeRefinementContext::getAvailabilityConditionVersionSourceRange(
       Node.getAsWhileStmt()->getCond(), Platform, Version);
 
   case Reason::Root:
-  case Reason::ResilienceBoundary:
+  case Reason::DeclImplicit:
     return SourceRange();
   }
 
@@ -312,8 +308,7 @@ void TypeRefinementContext::print(raw_ostream &OS, SourceManager &SrcMgr,
 
   OS << " versions=" << AvailabilityInfo.getOSVersion().getAsString();
 
-  if (getReason() == Reason::Decl
-      || getReason() == Reason::ResilienceBoundary) {
+  if (getReason() == Reason::Decl || getReason() == Reason::DeclImplicit) {
     Decl *D = Node.getAsDecl();
     OS << " decl=";
     if (auto VD = dyn_cast<ValueDecl>(D)) {
@@ -355,8 +350,8 @@ StringRef TypeRefinementContext::getReasonName(Reason R) {
   case Reason::Decl:
     return "decl";
 
-  case Reason::ResilienceBoundary:
-    return "resilience_boundary";
+  case Reason::DeclImplicit:
+    return "decl_implicit";
 
   case Reason::IfStmtThenBranch:
     return "if_then";

lib/Sema/TypeCheckAccess.cpp

@@ -1579,22 +1579,15 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
 
   void checkType(Type type, const TypeRepr *typeRepr, const Decl *context,
                  ExportabilityReason reason=ExportabilityReason::General,
-                 bool allowUnavailableProtocol=false) {
+                 DeclAvailabilityFlags flags=None) {
     // Don't bother checking errors.
     if (type && type->hasError())
       return;
-
-    DeclAvailabilityFlags flags = None;
-
-    // We allow a type to conform to a protocol that is less available than
-    // the type itself. This enables a type to retroactively model or directly
-    // conform to a protocol only available on newer OSes and yet still be used on
-    // older OSes.
-    //
-    // To support this, inside inheritance clauses we allow references to
-    // protocols that are unavailable in the current type refinement context.
-    if (allowUnavailableProtocol)
-      flags |= DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol;
+    
+    // If the decl which references this type is unavailable on the current
+    // platform, don't diagnose the availability of the type.
+    if (AvailableAttr::isUnavailable(context))
+      return;
 
     diagnoseTypeAvailability(typeRepr, type, context->getLoc(),
                              Where.withReason(reason), flags);
@@ -1753,20 +1746,29 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
   void visitNominalTypeDecl(const NominalTypeDecl *nominal) {
     checkGenericParams(nominal, nominal);
 
-    llvm::for_each(nominal->getInherited(),
-                   [&](TypeLoc inherited) {
-      checkType(inherited.getType(), inherited.getTypeRepr(),
-                nominal, ExportabilityReason::General,
-                /*allowUnavailableProtocol=*/true);
+    DeclAvailabilityFlags flags =
+        DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol;
+
+    // As a concession to source compatibility for API libraries, downgrade
+    // diagnostics about inheritance from a less available type when the
+    // following conditions are met:
+    // 1. The inherited type is only potentially unavailable before the
+    //    deployment target.
+    // 2. The inheriting type is `@usableFromInline`.
+    if (nominal->getAttrs().hasAttribute<UsableFromInlineAttr>())
+      flags |= DeclAvailabilityFlag::
+          WarnForPotentialUnavailabilityBeforeDeploymentTarget;
+
+    llvm::for_each(nominal->getInherited(), [&](TypeLoc inherited) {
+      checkType(inherited.getType(), inherited.getTypeRepr(), nominal,
+                ExportabilityReason::General, flags);
     });
   }
 
   void visitProtocolDecl(ProtocolDecl *proto) {
-    llvm::for_each(proto->getInherited(),
-                  [&](TypeLoc requirement) {
+    llvm::for_each(proto->getInherited(), [&](TypeLoc requirement) {
       checkType(requirement.getType(), requirement.getTypeRepr(), proto,
-                ExportabilityReason::General,
-                /*allowUnavailableProtocol=*/false);
+                ExportabilityReason::General);
     });
 
     if (proto->getTrailingWhereClause()) {
@@ -1841,11 +1843,10 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
     //
     // 1) If the extension defines conformances, the conformed-to protocols
     // must be exported.
-    llvm::for_each(ED->getInherited(),
-                   [&](TypeLoc inherited) {
-      checkType(inherited.getType(), inherited.getTypeRepr(),
-                ED, ExportabilityReason::General,
-                /*allowUnavailableProtocol=*/true);
+    llvm::for_each(ED->getInherited(), [&](TypeLoc inherited) {
+      checkType(inherited.getType(), inherited.getTypeRepr(), ED,
+                ExportabilityReason::General,
+                DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol);
     });
 
     auto wasWhere = Where;