[Generic Signature] Unify generic upper bound functions

Opened existentials should be erased to the dependent upper bound
if the dependent member can be reduced to a concrete type. This
allows the generic signature to support parameterized protocol types
and bound generic class types by producing a more specific constraint
instead of just a plain protocol or class.

Author: angela-laar

include/swift/Sema/ConstraintSystem.h

@@ -5532,12 +5532,7 @@ Expr *getArgumentLabelTargetExpr(Expr *fn);
 /// variable and anything that depends on it to their non-dependent bounds.
 Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
                                          TypeVariableType *openedTypeVar,
-                                         TypePosition outermostPosition,
-                                         bool wantNonDependentBound = true);
-
-Type transformFn(Type type, Type existentialBaseType,
-                            TypePosition initialPos);
-
+                                         TypePosition outermostPosition);
 
 /// Returns true if a reference to a member on a given base type will apply
 /// its curried self parameter, assuming it has one.

lib/AST/GenericSignature.cpp

@@ -628,6 +628,8 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
 Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
   assert(type->isTypeParameter());
 
+  auto &ctx = type->getASTContext();
+
   bool hasExplicitAnyObject = requiresClass(type);
 
   llvm::SmallVector<Type, 2> types;
@@ -636,141 +638,39 @@ Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
   // If the class contains a type parameter that cannot be reduced,
   // try looking for a non-dependent superclass.
   if (Type superclass = getSuperclassBound(type)) {
-    while (superclass &&
-           superclass->hasTypeParameter()) { // check if the current protocol
-                                             // has an associated type]
-      auto *boundgeneric = superclass->castTo<BoundGenericClassType>();
+    if (auto *boundgeneric = dyn_cast<BoundGenericClassType>(superclass)) {
 
       SmallVector<Type, 2> argTypes;
 
-      for (Type argTy : boundgeneric->getGenericArgs()) {
-        argTypes.push_back(getReducedType(argTy));
-      }
+      while (superclass && superclass->hasTypeParameter()) {
 
-      boundgeneric = BoundGenericClassType::get(
-          boundgeneric->getDecl(), boundgeneric->getParent(), argTypes);
-      if (!boundgeneric->hasDependentMember() &&
-          !boundgeneric->hasTypeParameter()) {
-        superclass = boundgeneric;
-        break;
+        argTypes.push_back(getReducedType(superclass));
+
+        boundgeneric = BoundGenericClassType::get(
+            boundgeneric->getDecl(), boundgeneric->getParent(), argTypes);
+        if (!boundgeneric->hasTypeParameter()) {
+          superclass = boundgeneric;
+          break;
+        }
+        superclass = superclass->getSuperclass();
+        // TO-DO: We should mark as 'requires coercion' if we have to erase to a
+        // non-dependent super type
       }
-      superclass = superclass->getSuperclass();
     }
+
     if (superclass) {
       types.push_back(superclass);
       hasExplicitAnyObject = false;
     }
   }
-  
+
   // Protocol Inheritence
   // If there is a reduced type, erase to it.
-  // Otherwise keep going until we hit a type that has unresolved components.
+  // Otherwise keep going until we hit a type that has
+  // no unresolved components.
   for (auto *proto : getRequiredProtocols(type)) {
     if (proto->requiresClass())
       hasExplicitAnyObject = false;
-    
-    auto *baseType = proto->getDeclaredInterfaceType()->castTo<ProtocolType>();
-
-    auto primaryAssocTypes = proto->getPrimaryAssociatedTypes();
-    if (!primaryAssocTypes.empty()) {
-      SmallVector<Type, 2> argTypes;
-
-      // Attempt to recover same-type requirements on primary associated types.
-      for (auto *assocType : primaryAssocTypes) {
-        // For each primary associated type A of P, compute the reduced type
-        // of T.[P]A.
-        auto *memberType = DependentMemberType::get(type, assocType);
-        auto reducedType = getReducedType(memberType);
-
-        // If the reduced type is at a lower depth than the root generic
-        // parameter of T, then it's constrained.
-        bool hasOuterGenericParam = false;
-        bool hasInnerGenericParam = false;
-        reducedType.visit([&](Type t) {
-          if (auto *paramTy = t->getAs<GenericTypeParamType>()) {
-            unsigned rootDepth = type->getRootGenericParam()->getDepth();
-            if (paramTy->getDepth() == rootDepth)
-              hasInnerGenericParam = true;
-            else {
-              assert(paramTy->getDepth() < rootDepth);
-              hasOuterGenericParam = true;
-            }
-          }
-        });
-
-        if (hasInnerGenericParam && hasOuterGenericParam) {
-          llvm::errs() << "Weird same-type requirements?\n";
-          llvm::errs() << "Interface type: " << type << "\n";
-          llvm::errs() << "Member type: " << memberType << "\n";
-          llvm::errs() << "Reduced member type: " << reducedType << "\n";
-          llvm::errs() << GenericSignature(this) << "\n";
-          abort();
-        }
-
-        if (!hasInnerGenericParam)
-          argTypes.push_back(reducedType);
-      }
-      // We should have either constrained all primary associated types,
-      // or none of them.
-      if (!argTypes.empty()) {
-        if (argTypes.size() != primaryAssocTypes.size()) {
-          llvm::errs() << "Not all primary associated types constrained?\n";
-          llvm::errs() << "Interface type: " << type << "\n";
-          llvm::errs() << GenericSignature(this) << "\n";
-          abort();
-        }
-
-        types.push_back(ParameterizedProtocolType::get(getASTContext(), baseType, argTypes));
-        continue;
-      }
-    }
-
-    types.push_back(baseType);
-  }
-
-  auto constraint = ProtocolCompositionType::get(
-      getASTContext(), types,
-      hasExplicitAnyObject);
-
-  if (!constraint->isConstraintType()) {
-    assert(constraint->getClassOrBoundGenericClass());
-    return constraint;
-  }
-
-  return ExistentialType::get(constraint);
-}
-
-Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
-  assert(type->isTypeParameter());
-
-  llvm::SmallVector<Type, 2> types;
-
-  auto &ctx = type->getASTContext();
-
-  bool hasExplicitAnyObject = requiresClass(type);
-
-  // FIXME: If the superclass bound is implied by one of our protocols, we
-  // shouldn't add it to the constraint type.
-  if (Type superclass = getSuperclassBound(type)) {
-    hasExplicitAnyObject = false;
-
-    if (auto *boundgeneric = superclass->getAs<BoundGenericClassType>()) {
-      SmallVector<Type, 2> argTypes;
-
-      for (Type argTy : boundgeneric->getGenericArgs()) {
-        argTypes.push_back(getReducedType(argTy));
-      }
-      boundgeneric = BoundGenericClassType::get(
-          boundgeneric->getDecl(), boundgeneric->getParent(), argTypes);
-      types.push_back(boundgeneric);
-    } else {
-      types.push_back(superclass);
-    }
-  }
-
-  for (auto proto : getRequiredProtocols(type)) {
-    if (proto->requiresClass())
-      hasExplicitAnyObject = false;
 
     auto *baseType = proto->getDeclaredInterfaceType()->castTo<ProtocolType>();
 
@@ -813,7 +713,6 @@ Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
         if (!hasInnerGenericParam)
           argTypes.push_back(reducedType);
       }
-
       // We should have either constrained all primary associated types,
       // or none of them.
       if (!argTypes.empty()) {
@@ -824,16 +723,16 @@ Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
           abort();
         }
 
-        types.push_back(ParameterizedProtocolType::get(ctx, baseType, argTypes));
+        types.push_back(ParameterizedProtocolType::get(getASTContext(),
+                                                       baseType, argTypes));
         continue;
       }
     }
-
-    types.push_back(baseType);
+    types.push_back(proto->getDeclaredInterfaceType());
   }
 
-  auto constraint = ProtocolCompositionType::get(
-     ctx, types, hasExplicitAnyObject);
+  auto constraint = ProtocolCompositionType::get(getASTContext(), types,
+                                                 hasExplicitAnyObject);
 
   if (!constraint->isConstraintType()) {
     assert(constraint->getClassOrBoundGenericClass());

lib/AST/Type.cpp

@@ -3572,7 +3572,7 @@ Type ArchetypeType::getExistentialType() const {
   auto interfaceType = getInterfaceType();
   auto genericSig = genericEnv->getGenericSignature();
 
-  auto upperBound = genericSig->getDependentUpperBounds(interfaceType);
+  auto upperBound = genericSig->getNonDependentUpperBounds(interfaceType);
 
   return genericEnv->mapTypeIntoContext(upperBound);
 }

lib/Sema/CSDiagnostics.cpp

@@ -8761,7 +8761,7 @@ bool MissingExplicitExistentialCoercion::fixItRequiresParens() const {
 void MissingExplicitExistentialCoercion::fixIt(
     InFlightDiagnostic &diagnostic) const {
 
-  if (ErasedResultType->hasDependentMember())
+  if (ErasedResultType->hasTypeParameter())
     return;
 
   bool requiresParens = fixItRequiresParens();

lib/Sema/CSFix.cpp

@@ -2496,10 +2496,8 @@ bool AddExplicitExistentialCoercion::isRequired(
         if (!existentialType)
           return Action::SkipChildren;
 
-        // let's grab the dependent upper bound here instead of nondependent
         auto erasedMemberTy = typeEraseOpenedExistentialReference(
-            Type(member), *existentialType, typeVar, TypePosition::Covariant,
-            false);
+            Type(member), *existentialType, typeVar, TypePosition::Covariant);
 
         // If result is an existential type and the base has `where` clauses
         // associated with its associated types, the call needs a coercion.
@@ -2510,13 +2508,7 @@ bool AddExplicitExistentialCoercion::isRequired(
         }
 
         if (erasedMemberTy->isExistentialType() &&
-            (erasedMemberTy->hasDependentMember() ||
-             erasedMemberTy->hasTypeParameter())) {
-          RequiresCoercion = true;
-          return Action::Stop;
-        }
-
-        if (erasedMemberTy->hasTypeVariable()) {
+             erasedMemberTy->hasTypeParameter()) {
           RequiresCoercion = true;
           return Action::Stop;
         }
@@ -2568,7 +2560,6 @@ bool AddExplicitExistentialCoercion::isRequired(
         case RequirementKind::Layout: {
           if (isAnchoredOn(req.getFirstType(), member->getAssocType()))
             return true;
-          
           break;
         }
 

lib/Sema/ConstraintSystem.cpp

@@ -1997,10 +1997,8 @@ static bool isMainDispatchQueueMember(ConstraintLocator *locator) {
 ///
 /// \note If a 'Self'-rooted type parameter is bound to a concrete type, this
 /// routine will recurse into the concrete type.
-static Type
-typeEraseExistentialSelfReferences(Type refTy, Type baseTy,
-                                   TypePosition outermostPosition,
-                                   bool wantNonDependentBound = true) {
+static Type typeEraseExistentialSelfReferences(Type refTy, Type baseTy,
+                                               TypePosition outermostPosition) {
   assert(baseTy->isExistentialType());
   if (!refTy->hasTypeParameter()) {
     return refTy;
@@ -2103,9 +2101,7 @@ typeEraseExistentialSelfReferences(Type refTy, Type baseTy,
       if (t->is<GenericTypeParamType>()) {
         erasedTy = baseTy;
       } else {
-        erasedTy = wantNonDependentBound
-                       ? existentialSig->getNonDependentUpperBounds(t)
-                       : existentialSig->getDependentUpperBounds(t);
+        erasedTy = existentialSig->getNonDependentUpperBounds(t);
       }
 
       if (metatypeDepth) {
@@ -2121,7 +2117,7 @@ typeEraseExistentialSelfReferences(Type refTy, Type baseTy,
 
 Type constraints::typeEraseOpenedExistentialReference(
     Type type, Type existentialBaseType, TypeVariableType *openedTypeVar,
-    TypePosition outermostPosition, bool wantNonDependentBound) {
+    TypePosition outermostPosition) {
   Type selfGP = GenericTypeParamType::get(false, 0, 0, type->getASTContext());
 
   // First, temporarily reconstitute the 'Self' generic parameter.
@@ -2138,8 +2134,8 @@ Type constraints::typeEraseOpenedExistentialReference(
   });
 
   // Then, type-erase occurrences of covariant 'Self'-rooted type parameters.
-  type = typeEraseExistentialSelfReferences(
-      type, existentialBaseType, outermostPosition, wantNonDependentBound);
+  type = typeEraseExistentialSelfReferences(type, existentialBaseType,
+                                            outermostPosition);
 
   // Finally, swap the 'Self'-corresponding type variable back in.
   return type.transformRec([&](TypeBase *t) -> Optional<Type> {

test/Constraints/opened_existentials.swift

@@ -256,7 +256,7 @@ func testExplicitCoercionRequirement(v: any B, otherV: any B & D) {
   _ = getTuple(v) // expected-error {{inferred result type '(any B, any P)' requires explicit coercion due to loss of generic requirements}} {{18-18=as (any B, any P)}}
   _ = getTuple(v) as (any B, any P) // Ok
   // Ok because T.C.A == Double
-  _ = getNoError(v) // expected-error {{inferred result type '(any B).C.A' requires explicit coercion due to loss of generic requirements}}
+  _ = getNoError(v)
 
   _ = getComplex(v) // expected-error {{inferred result type '([(x: (a: any P, b: Int), y: Int)], [Int : any P])' requires explicit coercion due to loss of generic requirements}} {{20-20=as ([(x: (a: any P, b: Int), y: Int)], [Int : any P])}}
   _ = getComplex(v) as ([(x: (a: any P, b: Int), y: Int)], [Int : any P]) // Ok
@@ -306,7 +306,6 @@ func testExplicitCoercionRequirement(v: any B, otherV: any B & D) {
   getP((v.getC() as any P))  // Ok - parens avoid opening suppression
 }
 
-// Generic Class Types
 class C1 {}
 class C2<T>: C1 {}
 
@@ -318,8 +317,15 @@ protocol P1 {
   func returnAssocTypeB() -> B
 }
 
-func testAssocReturn(p: any P1) { // should return C1
-  let _ = p.returnAssocTypeB() // expected-error {{inferred result type 'C1' requires explicit coercion due to loss of generic requirements}} {{29-29=as C1}}
+func testAssocReturn(p: any P1) {
+  let _ = p.returnAssocTypeB()  // returns C1
+}
+
+protocol Q2 : P1 where A == Int {}
+
+do {
+  let q: any Q2
+  let _ = q.returnAssocTypeB() // returns C1
 }
 
 // Test Primary Associated Types
@@ -330,8 +336,8 @@ protocol P2<A> {
   func returnAssocTypeB() -> B
 }
 
-func testAssocReturn(p: any P2<Int>) { // should return C2<A>
-  let _ = p.returnAssocTypeB()
+func testAssocReturn(p: any P2<Int>) {
+  let _ = p.returnAssocTypeB() // returns C2<A>
 }
 
 func testAssocReturn(p: any P2<any P2<String>>) {
@@ -346,9 +352,9 @@ protocol P3<A> {
   func returnAssocTypeCollection() -> any Collection<A>
 }
 
-// Confirm there is no way to access Primary Associated Type
+// Confirm there is no way to access Primary Associated Type directly
 func testPrimaryAssocReturn(p: any P3<Int>) {
-  let _ = p.returnPrimaryAssocTypeA() //expected-error {{inferred result type '(any P3<Int>).A' requires explicit coercion due to loss of generic requirements}}
+  let _ = p.returnPrimaryAssocTypeA()
 }
 
 func testPrimaryAssocCollection(p: any P3<Float>) {