Sema: Lift restriction on classes conforming to protocols with default implementations returning 'Self'

Now that we pass in the correct type metadata for 'Self', it is
sound for a class to conform to a protocol with a default implementation
for a method returning 'Self'.

Fixes <rdar://problem/23671426>.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -1452,6 +1452,11 @@ ERROR(witness_requires_dynamic_self,none,
       "method %0 in non-final class %1 must return `Self` to conform to "
       "protocol %2",
       (DeclName, Type, Type))
+ERROR(witness_requires_class_implementation,none,
+      "method %0 in non-final class %1 cannot be implemented in a "
+      "protocol extension because it returns `Self` and has associated type "
+      "requirements",
+      (DeclName, Type))
 ERROR(witness_not_accessible_proto,none,
       "%select{initializer %1|method %1|%select{|setter for }2property %1"
       "|subscript%select{| setter}2}0 must be declared "

lib/Sema/TypeCheckProtocol.cpp

@@ -3095,7 +3095,8 @@ void ConformanceChecker::checkNonFinalClassWitness(ValueDecl *requirement,
 
     // If the function has a dynamic Self, it's okay.
     if (auto func = dyn_cast<FuncDecl>(witness)) {
-      if (!func->hasDynamicSelf()) {
+      if (func->getDeclContext()->getAsClassOrClassExtensionContext() &&
+          !func->hasDynamicSelf()) {
         diagnoseOrDefer(requirement, false,
           [witness, requirement](NormalProtocolConformance *conformance) {
             auto proto = conformance->getProtocol();
@@ -3149,6 +3150,31 @@ void ConformanceChecker::checkNonFinalClassWitness(ValueDecl *requirement,
   // A non-final class can model a protocol requirement with a
   // contravariant Self, because here the witness will always have
   // a more general type than the requirement.
+
+  // If the witness is in a protocol extension, there's an additional
+  // constraint that either the requirement not produce 'Self' in a
+  // covariant position, or the type of the requirement does not involve
+  // associated types.
+  if (auto func = dyn_cast<FuncDecl>(witness)) {
+    if (func->getDeclContext()->getAsProtocolExtensionContext()) {
+      auto selfKindWithAssocTypes = Proto->findProtocolSelfReferences(
+          requirement,
+          /*allowCovariantParameters=*/false,
+          /*skipAssocTypes=*/false);
+      if (selfKindWithAssocTypes.other &&
+          selfKindWithAssocTypes.result) {
+        diagnoseOrDefer(requirement, false,
+          [witness, requirement](NormalProtocolConformance *conformance) {
+            auto proto = conformance->getProtocol();
+            auto &diags = proto->getASTContext().Diags;
+            diags.diagnose(witness->getLoc(),
+                           diag::witness_requires_class_implementation,
+                           requirement->getFullName(),
+                           conformance->getType());
+          });
+      }
+    }
+  }
 }
 
 ResolveWitnessResult

test/decl/protocol/conforms/self.swift

@@ -0,0 +1,37 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol P {
+  associatedtype T = Int
+
+  func hasDefault()
+  func returnsSelf() -> Self
+  func hasDefaultTakesT(_: T)
+  func returnsSelfTakesT(_: T) -> Self
+}
+
+extension P {
+  func hasDefault() {}
+
+  func returnsSelf() -> Self {
+    return self
+  }
+
+  func hasDefaultTakesT(_: T) {}
+
+  func returnsSelfTakesT(_: T) -> Self { // expected-error {{method 'returnsSelfTakesT' in non-final class 'Class' cannot be implemented in a protocol extension because it returns `Self` and has associated type requirements}}
+    return self
+  }
+}
+
+// This fails
+class Class : P {}
+
+// This succeeds, because the class is final
+final class FinalClass : P {}
+
+// This succeeds, because we're not using the default implementation
+class NonFinalClass : P {
+  func returnsSelfTakesT(_: T) -> Self {
+    return self
+  }
+}