Sema: Allow protocol compositions containing parameterized protocol types

For now, this only works with conformance requirements and not
existential types.

Fixes rdar://problem/92197412.

Author: slavapestov

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -64,6 +64,21 @@ using namespace swift;
 
 #define DEBUG_TYPE "TypeCheckDeclPrimary"
 
+static Type containsParameterizedProtocolType(Type inheritedTy) {
+  if (inheritedTy->is<ParameterizedProtocolType>()) {
+    return inheritedTy;
+  }
+
+  if (auto *compositionTy = inheritedTy->getAs<ProtocolCompositionType>()) {
+    for (auto memberTy : compositionTy->getMembers()) {
+      if (auto paramTy = containsParameterizedProtocolType(memberTy))
+        return paramTy;
+    }
+  }
+
+  return Type();
+}
+
 /// Check the inheritance clause of a type declaration or extension thereof.
 ///
 /// This routine performs detailed checking of the inheritance clause of the
@@ -212,10 +227,10 @@ static void checkInheritanceClause(
       inheritedAnyObject = { i, inherited.getSourceRange() };
     }
 
-    if (inheritedTy->is<ParameterizedProtocolType>()) {
+    if (auto paramTy = containsParameterizedProtocolType(inheritedTy)) {
       if (!isa<ProtocolDecl>(decl)) {
         decl->diagnose(diag::inheritance_from_parameterized_protocol,
-                       inheritedTy);
+                       paramTy);
       }
       continue;
     }
@@ -232,9 +247,15 @@ static void checkInheritanceClause(
         continue;
       }
 
+      // Classes and protocols can inherit from subclass existentials.
+      // For classes, we check for a duplicate superclass below.
+      // For protocols, the requirement machine emits a requirement
+      // conflict instead.
+      if (isa<ProtocolDecl>(decl))
+        continue;
+
       // AnyObject is not allowed except on protocols.
-      if (layout.hasExplicitAnyObject &&
-          !isa<ProtocolDecl>(decl)) {
+      if (layout.hasExplicitAnyObject) {
         decl->diagnose(diag::inheritance_from_anyobject);
         continue;
       }
@@ -243,12 +264,6 @@ static void checkInheritanceClause(
       if (!layout.explicitSuperclass)
         continue;
 
-      // Classes and protocols can inherit from subclass existentials.
-      // For classes, we check for a duplicate superclass below.
-      // For protocols, the GSB emits its own warning instead.
-      if (isa<ProtocolDecl>(decl))
-        continue;
-
       assert(isa<ClassDecl>(decl));
       assert(canHaveSuperclass);
       inheritedTy = layout.explicitSuperclass;

lib/Sema/TypeCheckType.cpp

@@ -3932,18 +3932,33 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     }
 
     // FIXME: Support compositions involving parameterized protocol types,
-    // like Collection<String> & Sendable, etc.
-    if (ty->isConstraintType() &&
-        !ty->is<ParameterizedProtocolType>()) {
-      auto layout = ty->getExistentialLayout();
-      if (auto superclass = layout.explicitSuperclass)
-        if (checkSuperclass(tyR->getStartLoc(), superclass))
-          continue;
-      if (!layout.getProtocols().empty())
+    // like 'any Collection<String> & Sendable', etc.
+    if (ty->isConstraintType()) {
+      if (ty->is<ProtocolType>()) {
         HasProtocol = true;
+        Members.push_back(ty);
+        continue;
+      }
 
-      Members.push_back(ty);
-      continue;
+      if (ty->is<ParameterizedProtocolType>() &&
+          options.isParameterizedProtocolSupported() &&
+          options.getContext() != TypeResolverContext::ExistentialConstraint) {
+        HasProtocol = true;
+        Members.push_back(ty);
+        continue;
+      }
+
+      if (ty->is<ProtocolCompositionType>()) {
+        auto layout = ty->getExistentialLayout();
+        if (auto superclass = layout.explicitSuperclass)
+          if (checkSuperclass(tyR->getStartLoc(), superclass))
+            continue;
+        if (!layout.getProtocols().empty())
+          HasProtocol = true;
+
+        Members.push_back(ty);
+        continue;
+      }
     }
 
     diagnose(tyR->getStartLoc(),

lib/Sema/TypeCheckType.h

@@ -132,7 +132,7 @@ enum class TypeResolverContext : uint8_t {
   /// Whether we are in the constraint type of an existential type.
   ExistentialConstraint,
 
-  /// Whether we are in a requirement of a generic declaration.
+  /// Whether we are in the constraint type of a conformance requirement.
   GenericRequirement,
 
   /// Whether we are in a same-type requirement of a generic

test/type/parameterized_existential.swift

@@ -1,9 +1,17 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking
 
-protocol Sequence<Element> {
+protocol Sequence<Element> { // expected-note {{'Sequence' declared here}}
   associatedtype Element
 }
 
+// 'any' is required here
+
+func takesSequenceOfInt1(_: Sequence<Int>) {}
+// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+
+func returnsSequenceOfInt1() -> Sequence<Int> {}
+// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+
 struct ConcreteSequence<Element> : Sequence {}
 
 extension Sequence {
@@ -72,3 +80,23 @@ protocol Pair<X, Y> where Self.X == Self.Y {
 
 func splay(_ x: some Pair<Int, String>) -> (Int, String) { fatalError() }
 // expected-error@-1 {{no type for 'some Pair<Int, String>.X' can satisfy both 'some Pair<Int, String>.X == String' and 'some Pair<Int, String>.X == Int'}}
+
+func typeExpr() {
+  _ = Sequence<Int>.self
+  // expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+
+  _ = any Sequence<Int>.self
+  // expected-error@-1 {{'self' is not a member type of protocol 'parameterized_existential.Sequence<Swift.Int>'}}
+
+  _ = (any Sequence<Int>).self
+}
+
+/// Not supported as a protocol composition term for now
+
+protocol SomeProto {}
+
+func protocolCompositionNotSupported1(_: SomeProto & Sequence<Int>) {}
+// expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}
+
+func protocolCompositionNotSupported2(_: any SomeProto & Sequence<Int>) {}
+// expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}

test/type/parameterized_protocol.swift

@@ -29,9 +29,9 @@ protocol Invalid5<Element, Element> {
 
 /// Test semantics
 
-protocol Sequence<Element> { // expected-note {{'Sequence' declared here}}
+protocol Sequence<Element> {
   associatedtype Element
-  // expected-note@-1 {{protocol requires nested type 'Element'; do you want to add it?}}
+  // expected-note@-1 2{{protocol requires nested type 'Element'; do you want to add it?}}
 }
 
 extension Sequence {
@@ -180,31 +180,23 @@ extension Sequence<Int> {
 }
 
 
-/// Cannot use parameterized protocol as the type of a value
+/// Protocol compositions
 
-func takesSequenceOfInt1(_: Sequence<Int>) {}
-// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+// CHECK-LABEL: .testComposition1@
+// CHECK-NEXT: Generic signature: <T where T : Sendable, T : Sequence, T.[Sequence]Element == Int>
+func testComposition1<T : Sequence<Int> & Sendable>(_: T) {}
 
-func returnsSequenceOfInt1() -> Sequence<Int> {}
-// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+// CHECK-LABEL: .testComposition2@
+// CHECK-NEXT: Generic signature:
+// CHECK-NEXT: Canonical generic signature: <τ_0_0 where τ_0_0 : Sendable, τ_0_0 : Sequence, τ_0_0.[Sequence]Element == Int>
+func testComposition2(_: some Sequence<Int> & Sendable) {}
 
-func takesSequenceOfInt2(_: any Sequence<Int>) {}
-
-func returnsSequenceOfInt2() -> any Sequence<Int> {}
-
-func typeExpr() {
-  _ = Sequence<Int>.self
-  // expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
-
-  _ = any Sequence<Int>.self
-  // expected-error@-1 {{'self' is not a member type of protocol 'parameterized_protocol.Sequence<Swift.Int>'}}
-
-  _ = (any Sequence<Int>).self
+// CHECK-LABEL: parameterized_protocol.(file).TestCompositionProtocol1@
+// CHECK: Requirement signature: <Self where Self.[TestCompositionProtocol1]S : Sendable, Self.[TestCompositionProtocol1]S : Sequence, Self.[TestCompositionProtocol1]S.[Sequence]Element == Int>
+protocol TestCompositionProtocol1 {
+  associatedtype S : Sequence<Int> & Sendable
 }
 
-/// Not supported as a protocol composition term for now
-
-protocol SomeProto {}
-
-func protocolCompositionNotSupported(_: SomeProto & Sequence<Int>) {}
-// expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}
+struct TestStructComposition : Sequence<Int> & Sendable {}
+// expected-error@-1 {{cannot inherit from protocol type with generic argument 'Sequence<Int>'}}
+// expected-error@-2 {{type 'TestStructComposition' does not conform to protocol 'Sequence'}}