Merge pull request #59179 from slavapestov/parameterized-protocol-improvements

Parameterized protocol improvements

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -3748,8 +3748,6 @@ ERROR(protocol_declares_unknown_primary_assoc_type,none,
       (Identifier, Type))
 ERROR(protocol_declares_duplicate_primary_assoc_type,none,
       "duplicate primary associated type name %0", (Identifier))
-ERROR(parameterized_protocol_not_supported,none,
-      "protocol type with type arguments can only be used as a generic constraint", ())
 ERROR(protocol_does_not_have_primary_assoc_type,none,
       "cannot specialize protocol type %0", (Type))
 ERROR(parameterized_protocol_type_argument_count_mismatch,none,

include/swift/AST/Types.h

@@ -6780,38 +6780,6 @@ inline TypeBase *TypeBase::getDesugaredType() {
   return cast<SugarType>(this)->getSinglyDesugaredType()->getDesugaredType();
 }
 
-inline bool TypeBase::hasSimpleTypeRepr() const {
-  // NOTE: Please keep this logic in sync with TypeRepr::isSimple().
-  switch (getKind()) {
-  case TypeKind::Function:
-  case TypeKind::GenericFunction:
-    return false;
-
-  case TypeKind::Metatype:
-    return !cast<const AnyMetatypeType>(this)->hasRepresentation();
-
-  case TypeKind::ExistentialMetatype:
-  case TypeKind::Existential:
-    return false;
-
-  case TypeKind::OpaqueTypeArchetype:
-  case TypeKind::OpenedArchetype:
-    return false;
-
-  case TypeKind::ProtocolComposition: {
-    // 'Any', 'AnyObject' and single protocol compositions are simple
-    auto composition = cast<const ProtocolCompositionType>(this);
-    auto memberCount = composition->getMembers().size();
-    if (composition->hasExplicitAnyObject())
-      return memberCount == 0;
-    return memberCount <= 1;
-  }
-
-  default:
-    return true;
-  }
-}
-
 } // end namespace swift
 
 namespace llvm {

lib/AST/Type.cpp

@@ -6224,6 +6224,46 @@ bool TypeBase::isForeignReferenceType() {
   return false;
 }
 
+bool TypeBase::hasSimpleTypeRepr() const {
+  // NOTE: Please keep this logic in sync with TypeRepr::isSimple().
+  switch (getKind()) {
+  case TypeKind::Function:
+  case TypeKind::GenericFunction:
+    return false;
+
+  case TypeKind::Metatype:
+    return !cast<const AnyMetatypeType>(this)->hasRepresentation();
+
+  case TypeKind::ExistentialMetatype:
+  case TypeKind::Existential:
+    return false;
+
+  case TypeKind::OpaqueTypeArchetype:
+  case TypeKind::OpenedArchetype:
+    return false;
+
+  case TypeKind::ProtocolComposition: {
+    // 'Any', 'AnyObject' and single protocol compositions are simple
+    auto composition = cast<const ProtocolCompositionType>(this);
+    auto memberCount = composition->getMembers().size();
+    if (composition->hasExplicitAnyObject())
+      return memberCount == 0;
+    return memberCount <= 1;
+  }
+
+  case TypeKind::GenericTypeParam: {
+    if (auto *decl = cast<const GenericTypeParamType>(this)->getDecl()) {
+      return !decl->isOpaqueType();
+    }
+
+    return true;
+  }
+
+  default:
+    return true;
+  }
+}
+
 bool CanType::isForeignReferenceType() {
   if (auto *classDecl = getPointer()->lookThroughAllOptionalTypes()->getClassOrBoundGenericClass())
     return classDecl->isForeignReferenceType();

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

@@ -629,15 +629,8 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
   auto &diags = ctx.Diags;
 
   if (auto *protoType = type->getAs<ProtocolType>()) {
-    // Build ParameterizedProtocolType if the protocol has a primary associated
-    // type and we're in a supported context (for now just generic requirements,
-    // inheritance clause, extension binding).
-    if (!resolution.getOptions().isParameterizedProtocolSupported()) {
-      diags.diagnose(loc, diag::parameterized_protocol_not_supported);
-      return ErrorType::get(ctx);
-    }
-
     auto *protoDecl = protoType->getDecl();
+
     auto assocTypes = protoDecl->getPrimaryAssociatedTypes();
     if (assocTypes.empty()) {
       diags.diagnose(loc, diag::protocol_does_not_have_primary_assoc_type,
@@ -657,6 +650,18 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
       return ErrorType::get(ctx);
     }
 
+    // Build ParameterizedProtocolType if the protocol has a primary associated
+    // type and we're in a supported context (for now just generic requirements,
+    // inheritance clause, extension binding).
+    if (!resolution.getOptions().isParameterizedProtocolSupported()) {
+      diags.diagnose(loc, diag::existential_requires_any,
+                     protoDecl->getDeclaredInterfaceType(),
+                     protoDecl->getExistentialType(),
+                     /*isAlias=*/isa<TypeAliasType>(type.getPointer()));
+
+      return ErrorType::get(ctx);
+    }
+
     // Disallow opaque types anywhere in the structure of the generic arguments
     // to a parameterized existential type.
     if (options.is(TypeResolverContext::ExistentialConstraint))
@@ -3932,18 +3937,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
@@ -288,13 +288,13 @@ class TypeResolutionOptions {
     switch (context) {
     case Context::Inherited:
     case Context::ExtensionBinding:
+    case Context::TypeAliasDecl:
+    case Context::GenericTypeAliasDecl:
     case Context::GenericRequirement:
     case Context::ExistentialConstraint:
     case Context::MetatypeBase:
       return true;
     case Context::None:
-    case Context::TypeAliasDecl:
-    case Context::GenericTypeAliasDecl:
     case Context::InExpression:
     case Context::ExplicitCastExpr:
     case Context::ForEachStmt:

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 {{use of protocol 'Sequence' as a type must be written 'any Sequence'}}
+
+func returnsSequenceOfInt1() -> Sequence<Int> {}
+// expected-error@-1 {{use of protocol 'Sequence' as a type must be written 'any Sequence'}}
+
 struct ConcreteSequence<Element> : Sequence {}
 
 extension Sequence {
@@ -65,10 +73,22 @@ func saturation(_ dry: any Sponge, _ wet: any Sponge<Int, Int>) {
   // expected-note@-1 {{did you mean to use 'as!' to force downcast?}}
 }
 
-protocol Pair<X, Y> where Self.X == Self.Y {
-  associatedtype X
-  associatedtype Y
+func typeExpr() {
+  _ = Sequence<Int>.self
+  // expected-error@-1 {{use of protocol 'Sequence' as a type must be written 'any Sequence'}}
+
+  _ = any Sequence<Int>.self
+  // expected-error@-1 {{'self' is not a member type of protocol 'parameterized_existential.Sequence<Swift.Int>'}}
+
+  _ = (any Sequence<Int>).self
 }
 
-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'}}
+/// 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,48 @@ extension Sequence<Int> {
 }
 
 
-/// Cannot use parameterized protocol as the type of a value
+/// Constraint aliases
 
-func takesSequenceOfInt1(_: Sequence<Int>) {}
-// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+typealias SequenceOfInt = Sequence<Int>
+typealias SequenceOf<T> = Sequence<T>
 
-func returnsSequenceOfInt1() -> Sequence<Int> {}
-// expected-error@-1 {{protocol type with type arguments can only be used as a generic constraint}}
+// CHECK-LABEL: .testConstraintAlias1@
+// CHECK-NEXT: Generic signature: <T where T : Sequence, T.[Sequence]Element == Int>
+func testConstraintAlias1<T : SequenceOfInt>(_: T) {}
 
-func takesSequenceOfInt2(_: any Sequence<Int>) {}
+// CHECK-LABEL: .testConstraintAlias2@
+// CHECK-NEXT: Generic signature: <T where T : Sequence, T.[Sequence]Element == String>
+func testConstraintAlias2<T : SequenceOf<String>>(_: T) {}
 
-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}}
+/// Protocol compositions
 
-  _ = any Sequence<Int>.self
-  // expected-error@-1 {{'self' is not a member type of protocol 'parameterized_protocol.Sequence<Swift.Int>'}}
+// CHECK-LABEL: .testComposition1@
+// CHECK-NEXT: Generic signature: <T where T : Sendable, T : Sequence, T.[Sequence]Element == Int>
+func testComposition1<T : Sequence<Int> & Sendable>(_: T) {}
 
-  _ = (any Sequence<Int>).self
+// 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) {}
+
+// 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
+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'}}
+
 
-protocol SomeProto {}
+/// Conflicts
+
+protocol Pair<X, Y> where Self.X == Self.Y {
+  associatedtype X
+  associatedtype Y
+}
 
-func protocolCompositionNotSupported(_: SomeProto & Sequence<Int>) {}
-// expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}
+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'}}