Sema: Check the availability of conformance type witnesses.

The type satisfying a protocol requirement must be at least as available as the
associated type for the requirement.

Resolves rdar://134093006.

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6834,6 +6834,35 @@ ERROR(conformance_availability_only_version_newer, none,
       "conformance of %0 to %1 is only available in %2 %3 or newer",
       (Type, Type, StringRef, llvm::VersionTuple))
 
+// Conformance checking type witness availability diagnostics
+
+ERROR(type_witness_availability_unavailable, none,
+      "%kindonly0 witnessing requirement %1 of %2 is unavailable"
+      "%select{ in %4|}3%select{|: %5}5",
+      (const ValueDecl *, const AssociatedTypeDecl *, const ProtocolDecl *,
+       bool, StringRef, StringRef))
+
+NOTE(type_witness_availability_marked_unavailable, none,
+     "%kindonly0 witnessing requirement %1 of %2 has been explicitly marked "
+     "unavailable here",
+     (const ValueDecl *, const AssociatedTypeDecl *, const ProtocolDecl *))
+
+NOTE(type_witness_availability_introduced_in_version, none,
+     "%kindonly0 witnessing requirement %1 of %2 was introduced in %3 %4",
+     (const ValueDecl *, const AssociatedTypeDecl *, const ProtocolDecl *,
+      StringRef, llvm::VersionTuple))
+
+NOTE(type_witness_availability_obsoleted, none,
+     "%kindonly0 witnessing requirement %1 of %2 was obsoleted in %3 %4",
+     (const ValueDecl *, const AssociatedTypeDecl *, const ProtocolDecl *,
+      StringRef, llvm::VersionTuple))
+
+ERROR(type_witness_availability_only_version_newer, none,
+      "%kindonly0 witnessing requirement %1 of %2 is "
+      "only available in %3 %4 or newer",
+      (const ValueDecl *, const AssociatedTypeDecl *, const ProtocolDecl *,
+       StringRef, llvm::VersionTuple))
+
 //------------------------------------------------------------------------------
 // MARK: @discardableResult
 //------------------------------------------------------------------------------

lib/Sema/TypeCheckAvailability.cpp

@@ -215,15 +215,20 @@ computeExportContextBits(ASTContext &Ctx, Decl *D, bool *spi, bool *implicit,
   }
 }
 
+static AvailabilityContext availabilityAtLocation(SourceLoc loc,
+                                                  const DeclContext *dc) {
+  auto &ctx = dc->getASTContext();
+  return ctx.LangOpts.DisableAvailabilityChecking
+             ? AvailabilityContext::alwaysAvailable()
+             : TypeChecker::overApproximateAvailabilityAtLocation(loc, dc);
+}
+
 ExportContext ExportContext::forDeclSignature(Decl *D) {
   auto &Ctx = D->getASTContext();
 
   auto *DC = D->getInnermostDeclContext();
   auto fragileKind = DC->getFragileFunctionKind();
-  auto runningOSVersion =
-      (Ctx.LangOpts.DisableAvailabilityChecking
-       ? AvailabilityContext::alwaysAvailable()
-       : TypeChecker::overApproximateAvailabilityAtLocation(D->getLoc(), DC));
+  auto runningOSVersion = availabilityAtLocation(D->getLoc(), DC);
   bool spi = Ctx.LangOpts.LibraryLevel == LibraryLevel::SPI;
   bool implicit = false;
   bool deprecated = false;
@@ -248,11 +253,7 @@ ExportContext ExportContext::forFunctionBody(DeclContext *DC, SourceLoc loc) {
   auto &Ctx = DC->getASTContext();
 
   auto fragileKind = DC->getFragileFunctionKind();
-  auto runningOSVersion =
-      (Ctx.LangOpts.DisableAvailabilityChecking
-       ? AvailabilityContext::alwaysAvailable()
-       : TypeChecker::overApproximateAvailabilityAtLocation(loc, DC));
-
+  auto runningOSVersion = availabilityAtLocation(loc, DC);
   bool spi = Ctx.LangOpts.LibraryLevel == LibraryLevel::SPI;
   bool implicit = false;
   bool deprecated = false;
@@ -294,6 +295,14 @@ ExportContext ExportContext::withExported(bool exported) const {
   return copy;
 }
 
+ExportContext ExportContext::withRefinedAvailability(const Decl *decl) const {
+  auto copy = *this;
+  auto runningOSVersion =
+      availabilityAtLocation(decl->getLoc(), decl->getInnermostDeclContext());
+  copy.RunningOSVersion.intersectWith(runningOSVersion);
+  return copy;
+}
+
 std::optional<PlatformKind> ExportContext::getUnavailablePlatformKind() const {
   if (Unavailable)
     return PlatformKind(Platform);
@@ -4536,6 +4545,94 @@ swift::diagnoseSubstitutionMapAvailability(SourceLoc loc,
   return hadAnyIssues;
 }
 
+static bool diagnoseExplicitUnavailabilityForTypeWitness(
+    const TypeDecl *witness, const AssociatedTypeDecl *assocType,
+    const ExportContext &where) {
+  auto diagnosticInfo = getExplicitUnavailabilityDiagnosticInfo(witness, where);
+  if (!diagnosticInfo)
+    return false;
+
+  ASTContext &ctx = witness->getASTContext();
+  auto &diags = ctx.Diags;
+  auto proto = assocType->getProtocol();
+  StringRef platform = diagnosticInfo->getPlatform();
+  const AvailableAttr *attr = diagnosticInfo->getAttr();
+
+  EncodedDiagnosticMessage EncodedMessage(attr->Message);
+  diags.diagnose(witness, diag::type_witness_availability_unavailable, witness,
+                 assocType, proto, platform.empty(), platform,
+                 EncodedMessage.Message);
+
+  switch (diagnosticInfo->getStatus()) {
+  case UnavailabilityDiagnosticInfo::Status::AlwaysUnavailable:
+    diags
+        .diagnose(witness, diag::type_witness_availability_marked_unavailable,
+                  witness, assocType, proto)
+        .highlight(attr->getRange());
+    break;
+  case UnavailabilityDiagnosticInfo::Status::IntroducedInVersion:
+    diags.diagnose(witness,
+                   diag::type_witness_availability_introduced_in_version,
+                   witness, assocType, proto,
+                   diagnosticInfo->getVersionedPlatform(), *attr->Introduced);
+    break;
+  case UnavailabilityDiagnosticInfo::Status::Obsoleted:
+    diags
+        .diagnose(witness, diag::type_witness_availability_obsoleted, witness,
+                  assocType, proto, diagnosticInfo->getVersionedPlatform(),
+                  *attr->Obsoleted)
+        .highlight(attr->getRange());
+    break;
+  }
+  return true;
+}
+
+static void diagnosePotentialUnavailabilityForTypeWitness(
+    const TypeDecl *witness, const AssociatedTypeDecl *assocType,
+    const DeclContext *dc, const UnavailabilityReason &reason) {
+  auto &ctx = dc->getASTContext();
+  auto proto = assocType->getProtocol();
+  auto requiredRange = reason.getRequiredOSVersionRange();
+  auto loc = witness->getLoc();
+
+  {
+    auto err = ctx.Diags.diagnose(
+        loc, diag::type_witness_availability_only_version_newer, witness,
+        assocType, proto, prettyPlatformString(targetPlatform(ctx.LangOpts)),
+        requiredRange.getLowerEndpoint());
+
+    // Direct a fixit to the error if an existing guard is nearly-correct
+    if (fixAvailabilityByNarrowingNearbyVersionCheck(loc, dc, requiredRange,
+                                                     ctx, err))
+      return;
+  }
+
+  fixAvailability(loc, dc, requiredRange, ctx);
+}
+
+bool swift::diagnoseTypeWitnessAvailability(const TypeDecl *witness,
+                                            const AssociatedTypeDecl *assocType,
+                                            const ExportContext &where) {
+  assert(!where.isImplicit());
+
+  if (witness->isInvalid())
+    return false;
+
+  if (diagnoseExplicitUnavailabilityForTypeWitness(witness, assocType, where))
+    return true;
+
+  auto dc = where.getDeclContext();
+  auto maybeUnavail = TypeChecker::checkDeclarationAvailability(
+      witness, where.withRefinedAvailability(assocType));
+  if (maybeUnavail.has_value()) {
+    diagnosePotentialUnavailabilityForTypeWitness(witness, assocType, dc,
+                                                  *maybeUnavail);
+    return true;
+  }
+
+  return false;
+}
+
 /// Should we warn that \p decl needs an explicit availability annotation
 /// in -require-explicit-availability mode?
 static bool declNeedsExplicitAvailability(const Decl *decl) {

lib/Sema/TypeCheckAvailability.h

@@ -153,6 +153,11 @@ class ExportContext {
   /// That is, this will perform a 'bitwise and' on the 'exported' bit.
   ExportContext withExported(bool exported) const;
 
+  /// Produce a new context with the same properties as this one, except the
+  /// availability of the resulting context is constrained by the availability
+  /// of \p decl if it is less available.
+  ExportContext withRefinedAvailability(const Decl *decl) const;
+
   DeclContext *getDeclContext() const { return DC; }
 
   AvailabilityContext getAvailabilityContext() const {
@@ -239,6 +244,12 @@ bool diagnoseSubstitutionMapAvailability(
     bool warnIfConformanceUnavailablePreSwift6 = false,
     bool suppressParameterizationCheckForOptional = false);
 
+/// Diagnoses use of unavailable types as witnesses for associated type
+/// requirements. Returns true if a diagnostic was emitted.
+bool diagnoseTypeWitnessAvailability(const TypeDecl *witness,
+                                     const AssociatedTypeDecl *assocType,
+                                     const ExportContext &context);
+
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic
 /// was emitted.
 bool diagnoseDeclAvailability(const ValueDecl *D, SourceRange R,

lib/Sema/TypeCheckProtocol.cpp

@@ -4897,6 +4897,9 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
           ctx.addDelayedConformanceDiag(conformance, false,
                                         DiagnoseUsableFromInline(typeDecl));
       }
+
+      // The type witness must be as available as the associated type.
+      diagnoseTypeWitnessAvailability(typeDecl, assocType, where);
     }
 
     // Make sure any associated type witnesses don't make reference to a

test/decl/protocol/associated_type_witness_availability.swift

@@ -0,0 +1,83 @@
+// RUN: %swift -typecheck -verify -target %target-cpu-apple-macosx12 %s
+// REQUIRES: OS=macosx
+
+protocol ProtoWithAssocType {
+  associatedtype A
+}
+
+struct ConformsToProtoWithAssocType_WitnessOld: ProtoWithAssocType {
+  @available(macOS 11, *)
+  struct A {} // Ok, A is less available than its parent but more available than the deployment target
+}
+
+struct ConformsToProtoWithAssocType_WitnessSame: ProtoWithAssocType {
+  @available(macOS 12, *)
+  struct A {} // Ok, A is less available than its parent but available at the deployment target
+}
+
+struct ConformsToProtoWithAssocType_WitnessTooNew: ProtoWithAssocType {
+  @available(macOS 13, *)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is only available in macOS 13 or newer}}
+}
+
+@available(macOS 13, *)
+struct ConformsToProtoWithAssocType_Newer: ProtoWithAssocType {
+  struct A {} // Ok, A is as available as the conformance
+}
+
+@available(macOS 13, *)
+struct ConformsToProtoWithAssocType_NewerAndWitnessTooNew: ProtoWithAssocType {
+  @available(macOS 14, *)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is only available in macOS 14 or newer}}
+}
+
+struct ConformsToProtoWithAssocType_WitnessUnavailable: ProtoWithAssocType {
+  @available(macOS, unavailable)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is unavailable in macOS}}
+  // expected-note@-1 {{struct witnessing requirement 'A' of 'ProtoWithAssocType' has been explicitly marked unavailable here}}
+}
+
+struct ConformsToProtoWithAssocType_WitnessUnavailableMessage: ProtoWithAssocType {
+  @available(*, unavailable, message: "Just don't")
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is unavailable: Just don't}}
+  // expected-note@-1 {{struct witnessing requirement 'A' of 'ProtoWithAssocType' has been explicitly marked unavailable here}}
+}
+
+struct ConformsToProtoWithAssocType_WitnessObsoleted: ProtoWithAssocType {
+  @available(macOS, obsoleted: 11)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is unavailable in macOS}}
+  // expected-note@-1 {{struct witnessing requirement 'A' of 'ProtoWithAssocType' was obsoleted in macOS 11}}
+}
+
+struct ConformsToProtoWithAssocType_WitnessIntroInSwift99: ProtoWithAssocType {
+  @available(swift, introduced: 99)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithAssocType' is unavailable}}
+  // expected-note@-1 {{struct witnessing requirement 'A' of 'ProtoWithAssocType' was introduced in Swift 99}}
+}
+
+
+@available(macOS, unavailable)
+struct ConformsToProtoWithAssocType_WitnessAndConformanceUnavailable: ProtoWithAssocType {
+  @available(macOS, unavailable)
+  struct A {} // Ok, the conformance is unavailable too.
+}
+
+
+protocol ProtoWithNewAssocType {
+  @available(macOS 13, *)
+  associatedtype A
+}
+
+struct ConformsToProtoWithNewAssocType_WitnessOld: ProtoWithNewAssocType {
+  struct A {} // Ok, A has always been available
+}
+
+struct ConformsToProtoWithNewAssocType_WitnessSame: ProtoWithNewAssocType {
+  @available(macOS 13, *)
+  struct A {} // Ok, A is as available as the associated type requirement
+}
+
+struct ConformsToProtoWithNewAssocType_WitnessTooNew: ProtoWithNewAssocType {
+  @available(macOS 14, *)
+  struct A {} // expected-error {{struct witnessing requirement 'A' of 'ProtoWithNewAssocType' is only available in macOS 14 or newer}}
+}