[Sema] Diagnose deprecated default implementations in the witness checker.

If a protocol provides a deprecated default implementation for a requirement
that is not deprecated, the compiler should emit a warning so the programmer
can provide an explicit implementation of the requirement. This is helpful
for staging in new protocol requirements that should be implemented in
conforming types.

(cherry picked from commit 005b45c)

Author: hborla

include/swift/AST/Attr.h

@@ -2693,6 +2693,10 @@ class DeclAttributes {
     return getUnavailable(ctx) != nullptr;
   }
 
+  bool isDeprecated(const ASTContext &ctx) const {
+    return getDeprecated(ctx) != nullptr;
+  }
+
   /// Determine whether there is a swiftVersionSpecific attribute that's
   /// unavailable relative to the provided language version.
   bool

include/swift/AST/DiagnosticsSema.def

@@ -3119,6 +3119,11 @@ ERROR(witness_unavailable,none,
         "unavailable %kind0 was used to satisfy a requirement of protocol %1%select{|: %2}2",
         (const ValueDecl *, Identifier, StringRef))
 
+WARNING(witness_deprecated,none,
+        "deprecated default implementation is used to satisfy %kind0 required by "
+        "protocol %1%select{|: %2}2",
+        (const ValueDecl *, Identifier, StringRef))
+
 ERROR(redundant_conformance,none,
       "redundant conformance of %0 to protocol %1", (Type, Identifier))
 ERROR(redundant_conformance_conditional,none,

include/swift/AST/RequirementMatch.h

@@ -239,6 +239,10 @@ enum class CheckKind : unsigned {
 
   /// The witness itself is inaccessible.
   WitnessUnavailable,
+
+  /// The witness is a deprecated default implementation provided by the
+  /// protocol.
+  DefaultWitnessDeprecated,
 };
 /// Describes the suitability of the chosen witness for
 /// the requirement.
@@ -464,4 +468,4 @@ struct RequirementMatch {
 
 }
 
-#endif // SWIFT_AST_REQUIREMENTMATCH_H
+#endif // SWIFT_AST_REQUIREMENTMATCH_H

lib/Sema/TypeCheckProtocol.cpp

@@ -1740,6 +1740,8 @@ checkWitnessAvailability(ValueDecl *requirement,
 
 RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
                                               const RequirementMatch &match) {
+  auto &ctx = getASTContext();
+
   if (!match.OptionalAdjustments.empty())
     return CheckKind::OptionalityConflict;
 
@@ -1769,7 +1771,7 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
     return RequirementCheck(CheckKind::Availability, requiredAvailability);
   }
 
-  if (requirement->getAttrs().isUnavailable(getASTContext()) &&
+  if (requirement->getAttrs().isUnavailable(ctx) &&
       match.Witness->getDeclContext() == DC) {
     return RequirementCheck(CheckKind::Unavailable);
   }
@@ -1792,11 +1794,11 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
     }
   }
 
-  if (match.Witness->getAttrs().isUnavailable(getASTContext()) &&
-      !requirement->getAttrs().isUnavailable(getASTContext())) {
+  if (match.Witness->getAttrs().isUnavailable(ctx) &&
+      !requirement->getAttrs().isUnavailable(ctx)) {
     auto nominalOrExtensionIsUnavailable = [&]() {
       if (auto extension = dyn_cast<ExtensionDecl>(DC)) {
-        if (extension->getAttrs().isUnavailable(getASTContext()))
+        if (extension->getAttrs().isUnavailable(ctx))
           return true;
       }
 
@@ -1813,6 +1815,20 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
       return CheckKind::WitnessUnavailable;
   }
 
+  // Warn about deprecated default implementations if the requirement is
+  // not deprecated, and the conformance is not deprecated.
+  bool isDefaultWitness = false;
+  if (auto *nominal = match.Witness->getDeclContext()->getSelfNominalTypeDecl())
+    isDefaultWitness = isa<ProtocolDecl>(nominal);
+  if (isDefaultWitness &&
+      match.Witness->getAttrs().isDeprecated(ctx) &&
+      !requirement->getAttrs().isDeprecated(ctx)) {
+    auto conformanceContext = ExportContext::forConformance(DC, Proto);
+    if (!conformanceContext.isDeprecated()) {
+      return RequirementCheck(CheckKind::DefaultWitnessDeprecated);
+    }
+  }
+
   return CheckKind::Success;
 }
 
@@ -4374,6 +4390,25 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
                          requirement->getName());
         });
       break;
+
+      case CheckKind::DefaultWitnessDeprecated:
+        getASTContext().addDelayedConformanceDiag(
+          Conformance, /*isError=*/false,
+          [witness, requirement](NormalProtocolConformance *conformance) {
+            auto &ctx = witness->getASTContext();
+            auto &diags = ctx.Diags;
+            SourceLoc diagLoc = getLocForDiagnosingWitness(conformance, witness);
+            auto *attr = witness->getAttrs().getDeprecated(ctx);
+            EncodedDiagnosticMessage EncodedMessage(attr->Message);
+            diags.diagnose(diagLoc, diag::witness_deprecated,
+                           witness, conformance->getProtocol()->getName(),
+                           EncodedMessage.Message);
+            emitDeclaredHereIfNeeded(diags, diagLoc, witness);
+            diags.diagnose(requirement, diag::kind_declname_declared_here,
+                           DescriptiveDeclKind::Requirement,
+                           requirement->getName());
+          });
+        break;
     }
 
     if (auto *classDecl = DC->getSelfClassDecl()) {

test/decl/protocol/req/deprecated.swift

@@ -0,0 +1,60 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol DeprecatedRequirement {
+  @available(*, deprecated)
+  func f()
+}
+
+extension DeprecatedRequirement {
+  @available(*, deprecated)
+  func f() {}
+}
+
+// No warning if both the requirement and the default implementation are deprecated
+struct S1: DeprecatedRequirement {}
+
+protocol DeprecatedDefault {
+  func f() // expected-note {{requirement 'f()' declared here}}
+}
+
+extension DeprecatedDefault {
+  @available(*, deprecated)
+  func f() {}  // expected-note {{'f()' declared here}}
+}
+
+// expected-warning@+1 {{deprecated default implementation is used to satisfy instance method 'f()' required by protocol 'DeprecatedDefault'}}
+struct S2: DeprecatedDefault {}
+
+// No warning if the conformance itself is deprecated
+@available(*, deprecated)
+struct S3: DeprecatedDefault {
+}
+
+struct S4: DeprecatedDefault {
+  func f() {}
+}
+
+struct S5 {}
+
+// No warning if the conformance itself is deprecated
+@available(*, deprecated)
+extension S5: DeprecatedDefault {}
+
+@available(*, deprecated)
+enum UnavailableEnum {
+  struct Nested: DeprecatedDefault {}
+}
+
+// Include message string from @available attribute if provided
+protocol DeprecatedDefaultWithMessage {
+  func f() // expected-note {{requirement 'f()' declared here}}
+}
+
+extension DeprecatedDefaultWithMessage {
+  @available(*, deprecated, message: "write it yourself")
+  func f() {} // expected-note {{'f()' declared here}}
+}
+
+
+// expected-warning@+1 {{deprecated default implementation is used to satisfy instance method 'f()' required by protocol 'DeprecatedDefaultWithMessage': write it yourself}}
+struct S6: DeprecatedDefaultWithMessage {}