WIP

Author: tshortli

include/swift/AST/DiagnosticsSema.def

@@ -6778,7 +6778,7 @@ WARNING(availability_enum_element_no_potential_warn,
 
 ERROR(availability_protocol_requires_version,
       none, "protocol %0 requires %1 to be available in %2 %3 and newer",
-      (Identifier, DeclName, StringRef, llvm::VersionTuple))
+      (const ProtocolDecl *, const ValueDecl *, StringRef, llvm::VersionTuple))
 
 NOTE(availability_protocol_requirement_here, none,
      "protocol requirement here", ())
@@ -6858,12 +6858,6 @@ NOTE(type_witness_availability_obsoleted, none,
      (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

@@ -4591,7 +4591,7 @@ swift::diagnoseSubstitutionMapAvailability(SourceLoc loc,
 }
 
 static bool diagnoseExplicitUnavailabilityForTypeWitness(
-    const TypeDecl *witness, const AssociatedTypeDecl *assocType,
+    SourceLoc loc, const TypeDecl *witness, const AssociatedTypeDecl *assocType,
     const ExportContext &where) {
   auto diagnosticInfo = getExplicitUnavailabilityDiagnosticInfo(witness, where);
   if (!diagnosticInfo)
@@ -4633,55 +4633,49 @@ static bool diagnoseExplicitUnavailabilityForTypeWitness(
 }
 
 static void diagnosePotentialUnavailabilityForTypeWitness(
-    const TypeDecl *witness, const AssociatedTypeDecl *assocType,
-    const DeclContext *dc, const UnavailabilityReason &reason) {
+    SourceLoc loc, const TypeDecl *witness, const AssociatedTypeDecl *assocType,
+    const DeclContext *dc, const AvailabilityContext &requiredAvailability) {
   auto &ctx = dc->getASTContext();
   auto proto = assocType->getProtocol();
-  auto requiredRange = reason.getRequiredOSVersionRange();
-  auto loc = witness->getLoc();
+  auto requiredRange = requiredAvailability.getOSVersion();
 
   {
     auto err = ctx.Diags.diagnose(
-        loc, diag::type_witness_availability_only_version_newer, witness,
-        assocType, proto, prettyPlatformString(targetPlatform(ctx.LangOpts)),
+        loc, diag::availability_protocol_requires_version, proto,
+        assocType, witness, 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))
+    if (fixAvailabilityByNarrowingNearbyVersionCheck(witness->getLoc(), dc,
+                                                     requiredRange, ctx, err))
       return;
   }
 
-  fixAvailability(loc, dc, requiredRange, ctx);
+  fixAvailability(witness->getLoc(), dc, requiredRange, ctx);
+
+  if (loc != witness->getLoc())
+    ctx.Diags.diagnose(witness, diag::decl_declared_here, witness);
 }
 
 bool swift::diagnoseTypeWitnessAvailability(
-    const TypeDecl *witness, const AssociatedTypeDecl *assocType,
+    SourceLoc loc, 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))
+  if (diagnoseExplicitUnavailabilityForTypeWitness(loc, 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);
+  auto requiredAvailability = AvailabilityContext::alwaysAvailable();
+  if (!TypeChecker::isAvailabilitySafeForConformance(conformance->getProtocol(), assocType, witness, dc, requiredAvailability)) {
+    diagnosePotentialUnavailabilityForTypeWitness(loc, witness, assocType, dc,
+                                                  requiredAvailability);
     return true;
   }
 

lib/Sema/TypeCheckAvailability.h

@@ -247,7 +247,7 @@ bool diagnoseSubstitutionMapAvailability(
 /// 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,
+    SourceLoc loc, const TypeDecl *witness, const AssociatedTypeDecl *assocType,
     const NormalProtocolConformance *conformance, const ExportContext &context);
 
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic

lib/Sema/TypeCheckDecl.cpp

@@ -1689,8 +1689,8 @@ SelfAccessKindRequest::evaluate(Evaluator &evaluator, FuncDecl *FD) const {
 }
 
 bool TypeChecker::isAvailabilitySafeForConformance(
-    ProtocolDecl *proto, ValueDecl *requirement, ValueDecl *witness,
-    DeclContext *dc, AvailabilityContext &requirementInfo) {
+    const ProtocolDecl *proto, const ValueDecl *requirement, const ValueDecl *witness,
+    const DeclContext *dc, AvailabilityContext &requirementInfo) {
 
   // We assume conformances in
   // non-SourceFiles have already been checked for availability.

lib/Sema/TypeCheckProtocol.cpp

@@ -4313,8 +4313,8 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
           SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
           diags.diagnose(
               diagLoc, diag::availability_protocol_requires_version,
-              conformance->getProtocol()->getName(),
-              witness->getName(),
+              conformance->getProtocol(),
+              witness,
               prettyPlatformString(targetPlatform(ctx.LangOpts)),
               check.RequiredAvailability.getOSVersion().getLowerEndpoint());
           emitDeclaredHereIfNeeded(diags, diagLoc, witness);
@@ -4909,9 +4909,10 @@ 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);
+    if (auto witness = type->getAnyNominal()) {
+      SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
+      diagnoseTypeWitnessAvailability(diagLoc, witness, assocType,
+                                      conformance, where);
     }
 
     // Make sure any associated type witnesses don't make reference to a

lib/Sema/TypeChecker.h

@@ -991,8 +991,8 @@ bool diagnoseConformanceExportability(SourceLoc loc,
 /// the provided conformance. On return, requiredAvailability holds th
 /// availability levels required for conformance.
 bool
-isAvailabilitySafeForConformance(ProtocolDecl *proto, ValueDecl *requirement,
-                                 ValueDecl *witness, DeclContext *dc,
+isAvailabilitySafeForConformance(const ProtocolDecl *proto, const ValueDecl *requirement,
+                                 const ValueDecl *witness, const DeclContext *dc,
                                  AvailabilityContext &requiredAvailability);
 
 /// Returns an over-approximation of the range of operating system versions

test/decl/protocol/associated_type_witness_availability.swift

@@ -116,23 +116,26 @@ protocol ProtoWithAssocTypeAndReq {
   func req(_ a: A)
 }
 
+@available(macOS 11, *)
+struct InferredOld {} // Ok, InferredOld is less available than its parent but more available than the deployment target
+
 struct ConformsToProtoWithAssocTypeAndReq_InferredWitnessOld: ProtoWithAssocTypeAndReq {
-  @available(macOS 11, *)
-  struct InferredOld {} // Ok, InferredOld is less available than its parent but more available than the deployment target
 
   func req(_ a: InferredOld) {}
 }
 
-struct ConformsToProtoWithAssocTypeAndReq_InferredWitnessSame: ProtoWithAssocTypeAndReq {
-  @available(macOS 12, *)
-  struct InferredSame {} // Ok, InferredSame is less available than its parent but available at the deployment target
+@available(macOS 12, *)
+struct InferredSame {} // Ok, InferredSame is less available than its parent but available at the deployment target
 
+struct ConformsToProtoWithAssocTypeAndReq_InferredWitnessSame: ProtoWithAssocTypeAndReq {
   func req(_ a: InferredSame) {}
 }
 
+@available(macOS 13, *)
+struct InferredTooNew {} // expected-note {{'InferredTooNew' declared here}}
+
 struct ConformsToProtoWithAssocTypeAndReq_InferredWitnessTooNew: ProtoWithAssocTypeAndReq {
-  @available(macOS 13, *)
-  struct InferredTooNew {} // expected-warning {{struct witnessing requirement 'A' of 'ProtoWithAssocTypeAndReq' is only available in macOS 13 or newer; this will be an error in a future Swift language mode}}
+  // expected-warning@-1 {{struct witnessing requirement 'A' of 'ProtoWithAssocTypeAndReq' is only available in macOS 13 or newer; this will be an error in a future Swift language mode}}
 
   @available(macOS 13, *)
   func req(_ a: InferredTooNew) {}