Enable availability attributes for associated types

Allow `@available` on associated types, which can be introduced after
the protocol was introduced. These work precisely how on expects,
because all of the infrastructure for introducing associated types
later on has been available for a while, with two small restrictions:

1. If one uses the primary associated type syntax (e.g., `P<A, B>`),
then the primary associated types must also be available in the
current context.
2. Adding a new associated type to a resilient protocol requires that
associated type to have a default.

Author: DougGregor

include/swift/AST/Attr.def

@@ -108,7 +108,7 @@ DECL_ATTR(_silgen_name, SILGenName,
   OnAbstractFunction | OnVar | LongAttribute | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   0)
 DECL_ATTR(available, Available,
-  OnAbstractFunction | OnGenericType | OnVar | OnSubscript | OnEnumElement | OnMacro | OnExtension | AllowMultipleAttributes | LongAttribute | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  OnAbstractFunction | OnAssociatedType | OnGenericType | OnVar | OnSubscript | OnEnumElement | OnMacro | OnExtension | AllowMultipleAttributes | LongAttribute | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   1)
 DECL_ATTR(objc, ObjC,
   OnAbstractFunction | OnClass | OnProtocol | OnExtension | OnVar | OnSubscript | OnEnum | OnEnumElement | ABIBreakingToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,

include/swift/AST/DiagnosticsSema.def

@@ -2851,7 +2851,6 @@ WARNING(assoc_type_default_conformance_failed,none,
 NOTE(assoc_type_default_here,none,
      "associated type %0 has default type %1 written here",
      (const AssociatedTypeDecl *, Type))
-
 ERROR(protocol_access,none,
       "%select{protocol must be declared %select{"
       "%select{private|fileprivate|internal|package|%error|%error}1"
@@ -6841,6 +6840,10 @@ ERROR(inlinable_decl_not_public,
 ERROR(inlinable_resilient_deinit,
       none, "deinitializer can only be '@inlinable' if the class is '@_fixed_layout'", ())
 
+ERROR(resilient_associated_type_less_available_requires_default,none,
+      "associated type %0 that is less available than its protocol must have a "
+      "default", (const AssociatedTypeDecl *))
+
 //------------------------------------------------------------------------------
 // MARK: @_specialize diagnostics
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckAvailability.cpp

@@ -3880,10 +3880,16 @@ class TypeReprAvailabilityWalker : public ASTWalker {
   DeclAvailabilityFlags flags;
 
   bool checkIdentTypeRepr(IdentTypeRepr *ITR) {
+    ArrayRef<AssociatedTypeDecl *> primaryAssociatedTypes;
+
     if (auto *typeDecl = ITR->getBoundDecl()) {
       auto range = ITR->getNameLoc().getSourceRange();
       if (diagnoseDeclAvailability(typeDecl, range, nullptr, where, flags))
         return true;
+
+      if (auto protocol = dyn_cast<ProtocolDecl>(typeDecl)) {
+        primaryAssociatedTypes = protocol->getPrimaryAssociatedTypes();
+      }
     }
 
     bool foundAnyIssues = false;
@@ -3895,6 +3901,17 @@ class TypeReprAvailabilityWalker : public ASTWalker {
       for (auto *genericArg : GTR->getGenericArgs()) {
         if (diagnoseTypeReprAvailability(genericArg, where, genericFlags))
           foundAnyIssues = true;
+
+        // The associated type that is being specified must be available as
+        // well.
+        if (!primaryAssociatedTypes.empty()) {
+          auto primaryAssociatedType = primaryAssociatedTypes.front();
+          primaryAssociatedTypes = primaryAssociatedTypes.drop_front();
+          if (diagnoseDeclAvailability(
+                  primaryAssociatedType, genericArg->getSourceRange(),
+                  nullptr, where, genericFlags))
+            foundAnyIssues = true;
+        }
       }
     }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2866,6 +2866,16 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         AT->diagnose(diag::kind_declared_here, DescriptiveDeclKind::Type);
       }
     }
+
+    // An associated type that was introduced after the protocol
+    auto module = AT->getDeclContext()->getParentModule();
+    if (!defaultType &&
+        module->getResilienceStrategy() == ResilienceStrategy::Resilient &&
+        AvailabilityInference::availableRange(proto, Ctx)
+          .isSupersetOf(AvailabilityInference::availableRange(AT, Ctx))) {
+      AT->diagnose(
+          diag::resilient_associated_type_less_available_requires_default, AT);
+    }
   }
 
   void checkUnsupportedNestedType(NominalTypeDecl *NTD) {

test/decl/protocol/associated_type_availability.swift

@@ -0,0 +1,55 @@
+// RUN: %swift -typecheck -verify -target %target-cpu-apple-macosx12 %s
+// REQUIRES: OS=macosx
+
+
+protocol P { }
+extension Int: P { }
+
+protocol P1<A, B> {
+  associatedtype A
+
+  @available(macOS 13, *)
+  associatedtype B: P
+}
+
+@available(macOS 13, *)
+struct ModelP1<A, B: P>: P1 {
+}
+
+// Associated types in where clauses
+func testWhereBad<T: P1, U>(_: T) where T.B == U { }
+// expected-error@-1{{'B' is only available in macOS 13 or newer}}
+// expected-note@-2{{add @available attribute to enclosing global function}}
+
+@available(macOS 13, *)
+func testWhereGood<T: P1, U>(_: T) where T.B == U { }
+
+// Associated types in opaque parameter position
+func testPrimaryOpaqueParamBad<U>(_: some P1<some Any, U>) {}
+// expected-error@-1 2{{'B' is only available in macOS 13 or newer}}
+// expected-note@-2 2{{add @available attribute to enclosing global function}}
+
+@available(macOS 13, *)
+func testPrimaryOpaqueParamGood<U: P>(_: some P1<some Any, U>) {}
+
+// Associated types in opaque result position
+func testPrimaryOpaqueResultBad<U: P>() -> some P1<String, U> {
+// expected-error@-1{{'B' is only available in macOS 13 or newer}}
+// expected-note@-2 2{{add @available attribute to enclosing global function}}
+  return ModelP1<String, U>()
+  // expected-error@-1{{'ModelP1' is only available in macOS 13 or newer}}
+  // expected-note@-2{{add 'if #available' version check}}
+}
+
+@available(macOS 13, *)
+func testPrimaryOpaqueResultGood<U: P>() -> some P1<String, U> {
+  return ModelP1<String, U>()
+}
+
+// Associated types in existentials
+func testPrimaryExistentialBad<U>(_: any P1<Int, U>) {}
+// expected-error@-1{{'B' is only available in macOS 13 or newer}}
+// expected-note@-2{{add @available attribute to enclosing global function}}
+
+@available(macOS 13, *)
+func testPrimaryExistentialGood<U>(_: any P1<Int, U>) {}

test/decl/protocol/associated_type_availability_resilient.swift

@@ -0,0 +1,18 @@
+// RUN: %swift -typecheck -verify -target %target-cpu-apple-macosx12 %s -enable-library-evolution
+// REQUIRES: OS=macosx
+
+
+protocol P { }
+extension Int: P { }
+
+@available(macOS 12, *)
+protocol P1 {
+  associatedtype A
+
+  @available(macOS 13, *)
+  associatedtype B: P
+  // expected-error@-1{{associated type 'B' that is less available than its protocol must have a default}}
+
+  @available(macOS 13, *)
+  associatedtype C: P = Int
+}