Sema: Diagnose unsupported existential types in more places

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

Author: slavapestov

lib/Sema/TypeCheckType.cpp

@@ -3283,6 +3283,17 @@ class UnsupportedProtocolVisitor
       });
     }
   }
+
+  void visitRequirements(ArrayRef<RequirementRepr> reqts) {
+    for (auto reqt : reqts) {
+      if (reqt.getKind() == RequirementReprKind::SameType) {
+        if (auto *repr = reqt.getFirstTypeLoc().getTypeRepr())
+          repr->walk(*this);
+        if (auto *repr = reqt.getSecondTypeLoc().getTypeRepr())
+          repr->walk(*this);
+      }
+    }
+  }
 };
 
 } // end anonymous namespace
@@ -3291,12 +3302,22 @@ void TypeChecker::checkUnsupportedProtocolType(Decl *decl) {
   if (!decl || decl->isInvalid())
     return;
 
-  // Type declarations are okay.
-  if (isa<TypeDecl>(decl))
-    return;
-
-  // Extensions are okay.
-  if (isa<ExtensionDecl>(decl))
+  if (auto *protocolDecl = dyn_cast<ProtocolDecl>(decl))
+    checkUnsupportedProtocolType(protocolDecl->getTrailingWhereClause());
+  else if (auto *genericDecl = dyn_cast<GenericTypeDecl>(decl))
+    checkUnsupportedProtocolType(genericDecl->getGenericParams());
+  else if (auto *assocType = dyn_cast<AssociatedTypeDecl>(decl))
+    checkUnsupportedProtocolType(assocType->getTrailingWhereClause());
+  else if (auto *extDecl = dyn_cast<ExtensionDecl>(decl))
+    checkUnsupportedProtocolType(extDecl->getTrailingWhereClause());
+  else if (auto *subscriptDecl = dyn_cast<SubscriptDecl>(decl))
+    checkUnsupportedProtocolType(subscriptDecl->getGenericParams());
+  else if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(decl)) {
+    if (!isa<AccessorDecl>(funcDecl))
+      checkUnsupportedProtocolType(funcDecl->getGenericParams());
+  }
+
+  if (isa<TypeDecl>(decl) || isa<ExtensionDecl>(decl))
     return;
 
   UnsupportedProtocolVisitor visitor(*this, /*checkStatements=*/false);
@@ -3310,3 +3331,19 @@ void TypeChecker::checkUnsupportedProtocolType(Stmt *stmt) {
   UnsupportedProtocolVisitor visitor(*this, /*checkStatements=*/true);
   stmt->walk(visitor);
 }
+
+void TypeChecker::checkUnsupportedProtocolType(TrailingWhereClause *whereClause) {
+  if (whereClause == nullptr)
+    return;
+
+  UnsupportedProtocolVisitor visitor(*this, /*checkStatements=*/false);
+  visitor.visitRequirements(whereClause->getRequirements());
+}
+
+void TypeChecker::checkUnsupportedProtocolType(GenericParamList *genericParams) {
+  if (genericParams  == nullptr)
+    return;
+
+  UnsupportedProtocolVisitor visitor(*this, /*checkStatements=*/false);
+  visitor.visitRequirements(genericParams->getRequirements());
+}

lib/Sema/TypeChecker.h

@@ -870,6 +870,14 @@ class TypeChecker final : public LazyResolver {
   /// Check for unsupported protocol types in the given statement.
   void checkUnsupportedProtocolType(Stmt *stmt);
 
+  /// Check for unsupported protocol types in the given generic requirement
+  /// list.
+  void checkUnsupportedProtocolType(TrailingWhereClause *whereClause);
+
+  /// Check for unsupported protocol types in the given generic requirement
+  /// list.
+  void checkUnsupportedProtocolType(GenericParamList *genericParams);
+
   /// Expose TypeChecker's handling of GenericParamList to SIL parsing.
   GenericEnvironment *handleSILGenericParams(GenericParamList *genericParams,
                                              DeclContext *DC);

test/Constraints/same_types.swift

@@ -303,9 +303,9 @@ func testSameTypeCommutativity4<U, T>(_ t: T, _ u: U)
 // expected-error@-1{{same-type requirement makes generic parameter 'T' non-generic}}
 
 func testSameTypeCommutativity5<U, T: P1>(_ t: T, _ u: U)
-  where P1 & P2 == T.Assoc { } // Ok, equivalent to T.Assoc == P1 & P2
+  where PPP & P3 == T.Assoc { } // Ok, equivalent to T.Assoc == PPP & P3
 
 // FIXME: Error emitted twice.
 func testSameTypeCommutativity6<U, T: P1>(_ t: T, _ u: U)
-  where U & P2 == T.Assoc { } // Equivalent to T.Assoc == U & P2
+  where U & P3 == T.Assoc { } // Equivalent to T.Assoc == U & P3
 // expected-error@-1 2 {{non-protocol, non-class type 'U' cannot be used within a protocol-constrained type}}

test/IDE/print_synthesized_extensions.swift

@@ -46,7 +46,7 @@ public extension P1 where T1 : P2 {
   public func ef2(t : T2) {}
 }
 
-public extension P1 where T1 == P2, T2 : P3 {
+public extension P1 where T1 == P3, T2 : P3 {
   public func ef3(t : T1) {}
   public func ef4(t : T1) {}
 }

test/SourceKit/InterfaceGen/Inputs/swift_mod_syn.swift

@@ -21,7 +21,7 @@ public extension P1 where T1 : P2 {
   public func ef2(t : T2) {}
 }
 
-public extension P1 where T1 == P2, T2 : P3 {
+public extension P1 where T1 == P3, T2 : P3 {
   public func ef3(t : T1) {}
   public func ef4(t : T1) {}
 }

test/type/protocol_types.swift

@@ -103,3 +103,38 @@ struct Outer {
 typealias X = Struct1<Pub & Bar>
 _ = Struct1<Pub & Bar>.self
 
+typealias BadAlias<T> = T
+where T : HasAssoc, T.Assoc == HasAssoc
+// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+
+struct BadStruct<T>
+where T : HasAssoc,
+      T.Assoc == HasAssoc {}
+// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+
+protocol BadProtocol where T == HasAssoc {
+  // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+  associatedtype T
+
+  associatedtype U : HasAssoc
+    where U.Assoc == HasAssoc
+  // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+}
+
+extension HasAssoc where Assoc == HasAssoc {}
+// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+
+func badFunction<T>(_: T)
+where T : HasAssoc,
+      T.Assoc == HasAssoc {}
+// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+
+struct BadSubscript {
+  subscript<T>(_: T) -> Int
+  where T : HasAssoc,
+        T.Assoc == HasAssoc {
+    // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+    get {}
+    set {}
+  }
+}