Sema: Check availability of 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/DiagnosticsCommon.def

@@ -51,6 +51,10 @@ WARNING(error_in_future_swift_version,none,
         "%0; this is an error in the Swift %1 language mode",
         (DiagnosticInfo *, unsigned))
 
+WARNING(error_in_a_future_swift_version,none,
+        "%0; this will be an error in a future Swift language mode",
+        (DiagnosticInfo *))
+
 // Generic disambiguation
 NOTE(while_parsing_as_left_angle_bracket,none,
      "while parsing this '<' as a type parameter bracket", ())

include/swift/AST/DiagnosticsSema.def

@@ -6835,6 +6835,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/AST/DiagnosticEngine.cpp

@@ -405,8 +405,13 @@ InFlightDiagnostic::limitBehaviorUntilSwiftVersion(
     // in a message that this will become an error in a later Swift
     // version. We do this before limiting the behavior, because
     // wrapIn will result in the behavior of the wrapping diagnostic.
-    if (limit >= DiagnosticBehavior::Warning)
-      wrapIn(diag::error_in_future_swift_version, majorVersion);
+    if (limit >= DiagnosticBehavior::Warning) {
+      if (majorVersion > 6) {
+        wrapIn(diag::error_in_a_future_swift_version);
+      } else {
+        wrapIn(diag::error_in_future_swift_version, majorVersion);
+      }
+    }
 
     limitBehavior(limit);
   }

lib/Sema/TypeCheckAvailability.cpp

@@ -216,15 +216,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;
@@ -249,11 +254,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;
@@ -295,6 +296,13 @@ ExportContext ExportContext::withExported(bool exported) const {
   return copy;
 }
 
+ExportContext
+ExportContext::withRefinedAvailability(AvailabilityContext availability) const {
+  auto copy = *this;
+  copy.RunningOSVersion.intersectWith(availability);
+  return copy;
+}
+
 std::optional<PlatformKind> ExportContext::getUnavailablePlatformKind() const {
   if (Unavailable)
     return PlatformKind(Platform);
@@ -4582,6 +4590,104 @@ 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());
+    err.warnUntilSwiftVersion(7);
+
+    // 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 NormalProtocolConformance *conformance, const ExportContext &where) {
+  if (where.isImplicit() || witness->isImplicit())
+    return false;
+
+  if (witness->isInvalid())
+    return false;
+
+  if (diagnoseExplicitUnavailabilityForTypeWitness(witness, assocType, where))
+    return true;
+
+  auto dc = conformance->getDeclContext();
+  auto &ctx = dc->getASTContext();
+
+  // The witness must be as available as the associated type and the conformance
+  // itself.
+  auto availability = AvailabilityInference::availableRange(assocType, ctx);
+  availability.intersectWith(
+      AvailabilityInference::availableRange(dc->getAsDecl(), ctx));
+
+  auto maybeUnavail = TypeChecker::checkDeclarationAvailability(
+      witness, where.withRefinedAvailability(availability));
+  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 \p availability
+  /// if it is less available.
+  ExportContext withRefinedAvailability(AvailabilityContext availability) 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 NormalProtocolConformance *conformance, 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

@@ -4908,6 +4908,12 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
       }
     }
 
+    // The type witness must be as available as the associated type.
+    if (auto witnessTypeDecl = type->getAnyNominal()) {
+      diagnoseTypeWitnessAvailability(witnessTypeDecl, assocType, conformance,
+                                      where);
+    }
+
     // Make sure any associated type witnesses don't make reference to a
     // type we can't emit metadata for, or we're going to have trouble at
     // runtime.