Sema: Ban protocol where clauses that place constraints on 'Self'

These will never work properly because of phase ordering issues with
the current declaration checker design. Since we can always express
the same thing with the protocol inheritance clause instead, just
diagnose this as an error instead of trying to hack around it.

Fixes <rdar://problem/38077232>, <https://bugs.swift.org/browse/SR-5581>.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -1833,6 +1833,10 @@ WARNING(protocol_composition_with_postfix,none,
         "protocol-constrained type with postfix '%0' is ambiguous "
         "and will be rejected in future version of Swift", (StringRef))
 
+ERROR(protocol_where_clause_self_requirement,none,
+      "constraint with subject type of 'Self' is not supported; "
+      "consider adding requirement to protocol inheritance clause instead", ())
+
 ERROR(invalid_protocol_composition_member,none,
       "non-protocol, non-class type %0 cannot be used within a "
       "protocol-constrained type", (Type))

lib/Sema/TypeCheckDecl.cpp

@@ -214,6 +214,8 @@ void TypeChecker::validateWhereClauses(ProtocolDecl *protocol,
                                        GenericTypeResolver *resolver) {
   TypeResolutionOptions options;
 
+  options |= TypeResolutionFlags::ProtocolWhereClause;
+
   if (auto whereClause = protocol->getTrailingWhereClause()) {
     revertGenericRequirements(whereClause->getRequirements());
     validateRequirements(whereClause->getWhereLoc(),

lib/Sema/TypeCheckGeneric.cpp

@@ -310,6 +310,31 @@ bool TypeChecker::validateRequirement(SourceLoc whereLoc, RequirementRepr &req,
   // Note that we are resolving within a requirement.
   options |= TypeResolutionFlags::GenericRequirement;
 
+  // Protocol where clauses cannot add conformance and superclass constraints
+  // to 'Self', because we need to be able to resolve inherited protocols and
+  // protocol superclasses before computing the protocol requirement signature.
+  if (options & TypeResolutionFlags::ProtocolWhereClause) {
+    if (req.getKind() == RequirementReprKind::TypeConstraint ||
+        req.getKind() == RequirementReprKind::LayoutConstraint) {
+      if (auto *subjectTyR = req.getSubjectLoc().getTypeRepr()) {
+        if (auto *componentTyR = dyn_cast<ComponentIdentTypeRepr>(subjectTyR)) {
+          if (componentTyR->getIdentifier() == Context.Id_Self) {
+            diagnose(req.getSubjectLoc().getLoc(),
+                     diag::protocol_where_clause_self_requirement);
+
+            req.getSubjectLoc().setType(ErrorType::get(Context));
+
+            if (req.getKind() == RequirementReprKind::TypeConstraint)
+              req.getConstraintLoc().setType(ErrorType::get(Context));
+
+            req.setInvalid();
+            return true;
+          }
+        }
+      }
+    }
+  }
+
   switch (req.getKind()) {
   case RequirementReprKind::TypeConstraint: {
     // Validate the types.

lib/Sema/TypeChecker.h

@@ -552,6 +552,9 @@ enum class TypeResolutionFlags : unsigned {
 
   /// Whether we are in a requirement of a generic declaration
   GenericRequirement = 1 << 26,
+
+  /// Whether we are in a protocol's where clause
+  ProtocolWhereClause = 1 << 27,
 };
 
 /// Option set describing how type resolution should work.

test/IDE/print_ast_tc_decls.swift

@@ -1352,11 +1352,11 @@ extension ProtocolToExtend where Self.Assoc == Int {}
 
 // Protocol with where clauses
 
-protocol ProtocolWithWhereClause : QuxProtocol where Qux == Int, Self : FooProtocol {}
-// PREFER_TYPE_REPR_PRINTING: protocol ProtocolWithWhereClause : FooProtocol, QuxProtocol where Self.Qux == Int {
+protocol ProtocolWithWhereClause : QuxProtocol where Qux == Int {}
+// PREFER_TYPE_REPR_PRINTING: protocol ProtocolWithWhereClause : QuxProtocol where Self.Qux == Int {
 
-protocol ProtocolWithWhereClauseAndAssoc : QuxProtocol where Qux == Int, Self : FooProtocol {
-// PREFER_TYPE_REPR_PRINTING-DAG: protocol ProtocolWithWhereClauseAndAssoc : FooProtocol, QuxProtocol where Self.Qux == Int {
+protocol ProtocolWithWhereClauseAndAssoc : QuxProtocol where Qux == Int {
+// PREFER_TYPE_REPR_PRINTING-DAG: protocol ProtocolWithWhereClauseAndAssoc : QuxProtocol where Self.Qux == Int {
   associatedtype A1 : QuxProtocol where A1 : FooProtocol, A1.Qux : QuxProtocol, Int == A1.Qux.Qux
 // PREFER_TYPE_REPR_PRINTING-DAG: {{^}}  associatedtype A1 : FooProtocol, QuxProtocol where Self.A1.Qux : QuxProtocol, Self.A1.Qux.Qux == Int{{$}}
 

test/Index/roles.swift

@@ -262,8 +262,12 @@ protocol AProtocol {
   // CHECK-NEXT: RelChild | protocol/Swift | AProtocol | s:14swift_ide_test9AProtocolP
 }
 
-protocol Q where Self: AProtocol {}
-// CHECK: [[@LINE-1]]:24 | protocol/Swift | AProtocol | [[AProtocol_USR]] | Ref | rel: 0
+protocol QBase {
+  associatedtype A
+}
+
+protocol Q : QBase where Self.A: AProtocol {}
+// CHECK: [[@LINE-1]]:34 | protocol/Swift | AProtocol | [[AProtocol_USR]] | Ref | rel: 0
 
 class ASubClass : AClass, AProtocol {
 // CHECK: [[@LINE-1]]:7 | class/Swift | ASubClass | s:14swift_ide_test9ASubClassC | Def | rel: 0

test/decl/protocol/req/where_clause.swift

@@ -16,3 +16,14 @@ protocol P3 : P2 {
 }
 
 func foo<S>(_: S) where S.SubSequence.Element == C1, S : P3 {}
+
+// Invalid where clauses
+protocol InvalidWhereClause1 where Self: AnyObject {}
+// expected-error@-1 {{constraint with subject type of 'Self' is not supported; consider adding requirement to protocol inheritance clause instead}}
+
+class AlsoBad {}
+
+protocol InvalidWhereClause2 {
+  associatedtype T where Self: AlsoBad
+  // expected-error@-1 {{constraint with subject type of 'Self' is not supported; consider adding requirement to protocol inheritance clause instead}}
+}