[Sema] Erase existential PATs to reduced type

When opening an existential return or parameter type that has a
primaray associated type, the primmary asssociated type should be
preserved if the type can be reduced to a concrete type. Otherwise,
we should erase the existential to a type with no dependent members
or generic parameters and diagnose explicit coercion is needed.

Author: angela-laar

include/swift/Sema/ConstraintSystem.h

@@ -5532,7 +5532,8 @@ 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);
+                                         TypePosition outermostPosition,
+                                         bool wantNonDependentBound = true);
 
 Type transformFn(Type type, Type existentialBaseType,
                             TypePosition initialPos);

lib/AST/GenericSignature.cpp

@@ -632,23 +632,26 @@ Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
 
   llvm::SmallVector<Type, 2> types;
   if (Type superclass = getSuperclassBound(type)) {
-    // If the class contains a type parameter, try looking for a non-dependent
-    // superclass.
-    while (superclass && superclass->hasTypeParameter()) {
-//      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 class contains a type parameter that cannot be reduced,
+    // try looking for a non-dependent superclass.
+    while (superclass &&
+           superclass->hasTypeParameter()) { // check if the current protocol
+                                             // has an associated type]
+      auto *boundgeneric = superclass->castTo<BoundGenericClassType>();
+
+      SmallVector<Type, 2> argTypes;
+
+      for (Type argTy : boundgeneric->getGenericArgs()) {
+        argTypes.push_back(getReducedType(argTy));
+      }
+
+      boundgeneric = BoundGenericClassType::get(
+          boundgeneric->getDecl(), boundgeneric->getParent(), argTypes);
+      if (!boundgeneric->hasDependentMember() &&
+          !boundgeneric->hasTypeParameter()) {
+        superclass = boundgeneric;
+        break;
+      }
       superclass = superclass->getSuperclass();
     }
     if (superclass) {
@@ -746,8 +749,20 @@ Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
   // 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)) {
-    types.push_back(superclass);
     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)) {

lib/Sema/CSDiagnostics.cpp

@@ -8760,6 +8760,10 @@ bool MissingExplicitExistentialCoercion::fixItRequiresParens() const {
 
 void MissingExplicitExistentialCoercion::fixIt(
     InFlightDiagnostic &diagnostic) const {
+
+  if (ErasedResultType->hasDependentMember())
+    return;
+
   bool requiresParens = fixItRequiresParens();
 
   auto callRange = getSourceRange();

lib/Sema/CSFix.cpp

@@ -2496,8 +2496,10 @@ 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);
+            Type(member), *existentialType, typeVar, TypePosition::Covariant,
+            false);
 
         // If result is an existential type and the base has `where` clauses
         // associated with its associated types, the call needs a coercion.
@@ -2506,13 +2508,17 @@ bool AddExplicitExistentialCoercion::isRequired(
           RequiresCoercion = true;
           return Action::Stop;
         }
-        
-        if (auto *const nominal = erasedMemberTy->getAs<NominalOrBoundGenericNominalType>()) {
-          // Bound Generic Nominals 
-          if (!hasConstrainedAssociatedTypes(member, *existentialType)) {
-            RequiresCoercion = true;
-            return Action::Stop;
-          }
+
+        if (erasedMemberTy->isExistentialType() &&
+            (erasedMemberTy->hasDependentMember() ||
+             erasedMemberTy->hasTypeParameter())) {
+          RequiresCoercion = true;
+          return Action::Stop;
+        }
+
+        if (erasedMemberTy->hasTypeVariable()) {
+          RequiresCoercion = true;
+          return Action::Stop;
         }
 
         return Action::SkipChildren;

lib/Sema/CSSimplify.cpp

@@ -12653,6 +12653,7 @@ ConstraintSystem::simplifyApplicableFnConstraint(
       // `as` coercion.
       if (AddExplicitExistentialCoercion::isRequired(
               *this, func2->getResult(), openedExistentials, locator)) {
+
         if (!shouldAttemptFixes())
           return SolutionKind::Error;
 

lib/Sema/ConstraintSystem.cpp

@@ -1998,9 +1998,9 @@ 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) {
+typeEraseExistentialSelfReferences(Type refTy, Type baseTy,
+                                   TypePosition outermostPosition,
+                                   bool wantNonDependentBound = true) {
   assert(baseTy->isExistentialType());
   if (!refTy->hasTypeParameter()) {
     return refTy;
@@ -2103,7 +2103,9 @@ typeEraseExistentialSelfReferences(
       if (t->is<GenericTypeParamType>()) {
         erasedTy = baseTy;
       } else {
-        erasedTy = existentialSig->getNonDependentUpperBounds(t);
+        erasedTy = wantNonDependentBound
+                       ? existentialSig->getNonDependentUpperBounds(t)
+                       : existentialSig->getDependentUpperBounds(t);
       }
 
       if (metatypeDepth) {
@@ -2114,12 +2116,12 @@ typeEraseExistentialSelfReferences(
       return erasedTy;
     });
   };
-  return transformFn(refTy, outermostPosition);    
+  return transformFn(refTy, outermostPosition);
 }
 
 Type constraints::typeEraseOpenedExistentialReference(
     Type type, Type existentialBaseType, TypeVariableType *openedTypeVar,
-    TypePosition outermostPosition) {
+    TypePosition outermostPosition, bool wantNonDependentBound) {
   Type selfGP = GenericTypeParamType::get(false, 0, 0, type->getASTContext());
 
   // First, temporarily reconstitute the 'Self' generic parameter.
@@ -2136,8 +2138,8 @@ Type constraints::typeEraseOpenedExistentialReference(
   });
 
   // Then, type-erase occurrences of covariant 'Self'-rooted type parameters.
-  type = typeEraseExistentialSelfReferences(type, existentialBaseType,
-                                            outermostPosition);
+  type = typeEraseExistentialSelfReferences(
+      type, existentialBaseType, outermostPosition, wantNonDependentBound);
 
   // Finally, swap the 'Self'-corresponding type variable back in.
   return type.transformRec([&](TypeBase *t) -> Optional<Type> {
@@ -2242,16 +2244,25 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
     const auto selfGP = cast<GenericTypeParamType>(
         outerDC->getSelfInterfaceType()->getCanonicalType());
     auto openedTypeVar = replacements.lookup(selfGP);
+
     type = typeEraseOpenedExistentialReference(type, baseObjTy, openedTypeVar,
                                                TypePosition::Covariant);
 
+    Type contextualTy;
+
+    if (auto *anchor = getAsExpr(simplifyLocatorToAnchor(locator))) {
+      contextualTy =
+          getContextualType(getParentExpr(anchor), /*forConstraint=*/false);
+    }
+
     if (!hasFixFor(locator) &&
         AddExplicitExistentialCoercion::isRequired(
             *this, nonErasedResultTy,
             [&](TypeVariableType *typeVar) {
               return openedTypeVar == typeVar ? baseObjTy : Optional<Type>();
             },
-            locator)) {
+            locator) &&
+        !contextualTy) {
       recordFix(AddExplicitExistentialCoercion::create(
           *this, getResultType(type), locator));
     }

test/decl/protocol/existential_member_accesses_self_assoctype.swift

@@ -637,6 +637,7 @@ do {
   let exist: any InvalidTypeParameters
 
   exist.method1() // expected-error {{instance method 'method1()' requires that 'Self.A' conform to 'InvalidTypeParameters'}}
+  // expected-error@-1 {{inferred result type '(any InvalidTypeParameters).A.A' requires explicit coercion due to loss of generic requirements}}{{16-16=as (any InvalidTypeParameters).A.A}}
   exist.method2(false) // expected-error {{instance method 'method2' requires that 'Self.A' conform to 'InvalidTypeParameters'}}
   exist.method3(false, false) // expected-error {{instance method 'method3' requires that 'Self.A' conform to 'InvalidTypeParameters'}}
   // expected-error@-1 {{member 'method3' cannot be used on value of type 'any InvalidTypeParameters'; consider using a generic constraint instead}}
@@ -794,14 +795,14 @@ do {
 
     let _: (
       Struct<Bool>, (any ConcreteAssocTypes).Type, () -> Bool
-    ) -> any Class<Struct<Bool>.Inner> & ConcreteAssocTypes = arg.method4
+    ) -> any Class<Struct<Bool>.Inner> & ConcreteAssocTypes = arg.method4 // expected-error {{inferred result type 'any Class<Struct<(any ConcreteAssocTypes).A7>.Inner> & ConcreteAssocTypes' requires explicit coercion due to loss of generic requirements}}{{74-74=as any Class<Struct<(any ConcreteAssocTypes).A7>.Inner> & ConcreteAssocTypes}}
 
     let _: (
       Struct<Bool>, (any ConcreteAssocTypes).Type, () -> Bool
     ) -> any Class<Struct<Bool>.Inner> & ConcreteAssocTypes = arg.property4
 
     let _: any Class<Struct<Bool>.Inner> & ConcreteAssocTypes =
-      arg[
+      arg[ // expected-error {{inferred result type 'any Class<Struct<(any ConcreteAssocTypes).A7>.Inner> & ConcreteAssocTypes' requires explicit coercion due to loss of generic requirements}}{{7-7=(}} {{807:8-8=as any Class<Struct<(any ConcreteAssocTypes).A7>.Inner> & ConcreteAssocTypes)}}
         subscript4: Struct<Bool>(), (any ConcreteAssocTypes).self, { true }
       ]
   }
@@ -914,31 +915,45 @@ do {
   let _: Any = exist.method1()
   let _: AnyObject = exist.method2()
   let _: any CovariantAssocTypeErasure = exist.method3()
-  let _: Class2Base = exist.method4() // expected-error {{inferred result type 'Class2Base' requires explicit coercion due to loss of generic requirements}}
-  let _: Class2Base = exist.method5() // expected-error {{inferred result type 'Class2Derived<any CovariantAssocTypeErasure>' requires explicit coercion due to loss of generic requirements}}
+  let _: Class2Base = exist.method4()
+  let _: Class2Base = exist.method5()
   let _: any Class2Base & CovariantAssocTypeErasure = exist.method6()
   let _: any Class2Base & CovariantAssocTypeErasure = exist.method7()
-
-  let _: Any? = exist.method8() // expected-error {{inferred result type 'Optional<Any>' requires explicit coercion due to loss of generic requirements}}
+  let _: Any? = exist.method8()
   let _: (AnyObject, Bool) = exist.method9()
   let _: any CovariantAssocTypeErasure.Type = exist.method10()
-  let _: Array<Class2Base> = exist.method11() // expected-error {{inferred result type 'Array<Class2Base>' requires explicit coercion due to loss of generic requirements}}
-  let _: Dictionary<String, Class2Base> = exist.method12() //expected-error {{inferred result type 'Dictionary<String, Class2Derived<any CovariantAssocTypeErasure>>' requires explicit coercion due to loss of generic requirements}}
+  let _: Array<Class2Base> = exist.method11()
+  let _: Dictionary<String, Class2Base> = exist.method12()
+
+  let _ = exist.method1()
+  let _ = exist.method2()
+  let _ = exist.method3()
+  let _ = exist.method4()
+  let _ = exist.method5() // expected-error {{inferred result type 'Class2Base' requires explicit coercion due to loss of generic requirements}}{{24-24=as Class2Base}}
+  let _ = exist.method6()
+  let _ = exist.method7() // expected-error {{inferred result type 'any Class2Base & CovariantAssocTypeErasure' requires explicit coercion due to loss of generic requirements}}{{24-24=as any Class2Base & CovariantAssocTypeErasure}}
+  let _ = exist.method8()
+  let _ = exist.method9()
+  let _ = exist.method10()
+  let _ = exist.method11()
+  let _ = exist.method12() // expected-error {{inferred result type 'Dictionary<String, Class2Base>' requires explicit coercion due to loss of generic requirements}}{{25-25=as Dictionary<String, Class2Base>}}
+  
+
 }
 do {
   let exist: any CovariantAssocTypeErasureDerived
 
   let _: any CovariantAssocTypeErasureDerived = exist.method1()
-  let _: Class2Base = exist.method2() //expected-error {{inferred result type 'Class2Base' requires explicit coercion due to loss of generic requirements}}
+  let _: Class2Base = exist.method2()
   let _: any CovariantAssocTypeErasureDerived = exist.method3()
   let _: any Class2Base & CovariantAssocTypeErasureDerived = exist.method4()
   let _: any Class2Base & CovariantAssocTypeErasureDerived = exist.method5()
   let _: any Class2Base & CovariantAssocTypeErasureDerived = exist.method6()
   let _: any Class2Base & CovariantAssocTypeErasure & Sequence = exist.method7()
 
-  let _: (any CovariantAssocTypeErasureDerived)? = exist.method8() //expected-error {{inferred result type 'Optional<any CovariantAssocTypeErasureDerived>' requires explicit coercion due to loss of generic requirements}}
+  let _: (any CovariantAssocTypeErasureDerived)? = exist.method8()
   let _: (Class2Base, Bool) = exist.method9()
   let _: any CovariantAssocTypeErasureDerived.Type = exist.method10()
-  let _: Array<any Class2Base & CovariantAssocTypeErasureDerived> = exist.method11() //expected-error {{inferred result type 'Array<any Class2Base & CovariantAssocTypeErasureDerived>' requires explicit coercion due to loss of generic requirements}}
-  let _: Dictionary<String, any Class2Base & CovariantAssocTypeErasureDerived> = exist.method12() //expected-error {{inferred result type 'Dictionary<String, any Class2Derived<any CovariantAssocTypeErasureDerived> & CovariantAssocTypeErasureDerived>' requires explicit coercion due to loss of generic requirements}}
+  let _: Array<any Class2Base & CovariantAssocTypeErasureDerived> = exist.method11()
+  let _: Dictionary<String, any Class2Base & CovariantAssocTypeErasureDerived> = exist.method12()
 }