AST: An opaque generic parameter is not 'simple' for purposes of type printing

Author: slavapestov

include/swift/AST/Types.h

@@ -6752,38 +6752,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

@@ -6222,6 +6222,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();

test/type/parameterized_existential.swift

@@ -73,14 +73,6 @@ 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 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 {{use of protocol 'Sequence' as a type must be written 'any Sequence'}}

test/type/parameterized_protocol.swift

@@ -193,6 +193,7 @@ func testConstraintAlias1<T : SequenceOfInt>(_: T) {}
 // CHECK-NEXT: Generic signature: <T where T : Sequence, T.[Sequence]Element == String>
 func testConstraintAlias2<T : SequenceOf<String>>(_: T) {}
 
+
 /// Protocol compositions
 
 // CHECK-LABEL: .testComposition1@
@@ -212,4 +213,15 @@ protocol TestCompositionProtocol1 {
 
 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'}}
+// expected-error@-2 {{type 'TestStructComposition' does not conform to protocol 'Sequence'}}
+
+
+/// Conflicts
+
+protocol Pair<X, Y> where Self.X == Self.Y {
+  associatedtype X
+  associatedtype 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'}}