[Sema] When explicit existential types are enabled, type witnesses that

resolve to ProtocolType or ProtocolCompositionType are always existential
types.

This can happen because type aliases to protocol constraints can also be
used as type witnesses. The type alias itself is still a constraint,
because it can be used in generic signatures in addition to being used
as an existential type, e.g. in parameter position. So, we need to wrap
the type alias in an ExistentialType during type witness resolution.

Author: hborla

include/swift/AST/Type.h

@@ -385,6 +385,7 @@ class CanType : public Type {
 
   static bool isReferenceTypeImpl(CanType type, const GenericSignatureImpl *sig,
                                   bool functionsCount);
+  static bool isConstraintTypeImpl(CanType type);
   static bool isExistentialTypeImpl(CanType type);
   static bool isAnyExistentialTypeImpl(CanType type);
   static bool isObjCExistentialTypeImpl(CanType type);
@@ -457,6 +458,10 @@ class CanType : public Type {
                                /*functions count*/ false);
   }
 
+  bool isConstraintType() const {
+    return isConstraintTypeImpl(*this);
+  }
+
   /// Is this type existential?
   bool isExistentialType() const {
     return isExistentialTypeImpl(*this);

include/swift/AST/Types.h

@@ -727,6 +727,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
     return getRecursiveProperties().hasDependentMember();
   }
 
+  /// Whether this type represents a generic constraint.
+  bool isConstraintType() const;
+
   /// isExistentialType - Determines whether this type is an existential type,
   /// whose real (runtime) type is unknown but which is known to conform to
   /// some set of protocols. Protocol and protocol-conformance types are
@@ -6335,6 +6338,15 @@ inline GenericTypeParamType *TypeBase::getRootGenericParam() {
   return t->castTo<GenericTypeParamType>();
 }
 
+inline bool TypeBase::isConstraintType() const {
+  return getCanonicalType().isConstraintType();
+}
+
+inline bool CanType::isConstraintTypeImpl(CanType type) {
+  return (isa<ProtocolType>(type) ||
+          isa<ProtocolCompositionType>(type));
+}
+
 inline bool TypeBase::isExistentialType() {
   return getCanonicalType().isExistentialType();
 }

lib/Sema/TypeCheckProtocol.cpp

@@ -4783,6 +4783,23 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
     auto memberType = TypeChecker::substMemberTypeWithBase(DC->getParentModule(),
                                                            typeDecl, Adoptee);
 
+    // Type witnesses that resolve to constraint types are always
+    // existential types. This can only happen when the type witness
+    // is explicitly written with a type alias. The type alias itself
+    // is still a constraint type because it can be used as both a
+    // type witness and as a generic constraint.
+    //
+    // With SE-0335, using a type alias as both a type witness and a generic
+    // constraint will be disallowed in Swift 6, because existential types
+    // must be explicit, and a generic constraint isn't a valid type witness.
+    //
+    // Note that Any and AnyObject aren't yet resolved using ExistentialType.
+    if (getASTContext().LangOpts.EnableExplicitExistentialTypes &&
+        memberType->isConstraintType() &&
+        !(memberType->isAny() || memberType->isAnyObject())) {
+      memberType = ExistentialType::get(memberType);
+    }
+
     if (!viableTypes.insert(memberType->getCanonicalType()).second)
       continue;
 

test/type/explicit_existential.swift

@@ -164,3 +164,24 @@ func testMetatypes() {
 }
 
 func generic<T: any P1>(_ t: T) {} // expected-error {{type 'T' constrained to non-protocol, non-class type 'any P1'}}
+
+protocol RawRepresentable {
+  associatedtype RawValue
+  var rawValue: RawValue { get }
+}
+
+enum E1: RawRepresentable {
+  typealias RawValue = P1
+
+  var rawValue: P1 {
+    return ConcreteComposition()
+  }
+}
+
+enum E2: RawRepresentable {
+  typealias RawValue = any P1
+
+  var rawValue: any P1 {
+    return ConcreteComposition()
+  }
+}