[Generic Signature] Unify generic upper bound functions

angela-laar · angela-laar · commit b7ea96104d69 · 2023-05-08T19:00:58.000-07:00
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.
diff --git a/include/swift/Sema/ConstraintSystem.h b/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.
diff --git a/lib/AST/GenericSignature.cpp b/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,35 +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;
+        // check if the current class has generic arguments
+        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();
+        // 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;
@@ -720,12 +726,12 @@ Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
           abort();
         }
 
-        types.push_back(ParameterizedProtocolType::get(getASTContext(), baseType, argTypes));
+        types.push_back(ParameterizedProtocolType::get(getASTContext(),
+                                                       baseType, argTypes));
         continue;
       }
     }
-
-    types.push_back(baseType);
+    types.push_back(proto->getDeclaredInterfaceType());
   }
 
   auto constraint = ProtocolCompositionType::get(
@@ -740,109 +746,6 @@ Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
   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>();
-
-    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(ctx, baseType, argTypes));
-        continue;
-      }
-    }
-
-    types.push_back(baseType);
-  }
-
-  auto constraint = ProtocolCompositionType::get(
-     ctx, types, hasExplicitAnyObject);
-
-  if (!constraint->isConstraintType()) {
-    assert(constraint->getClassOrBoundGenericClass());
-    return constraint;
-  }
-
-  return ExistentialType::get(constraint);
-}
-
 void GenericSignature::Profile(llvm::FoldingSetNodeID &id) const {
   return GenericSignature::Profile(id, getPointer()->getGenericParams(),
                                      getPointer()->getRequirements());
diff --git a/lib/AST/Type.cpp b/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);
 }
diff --git a/lib/Sema/CSFix.cpp b/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.
@@ -2516,11 +2514,6 @@ bool AddExplicitExistentialCoercion::isRequired(
           return Action::Stop;
         }
 
-        if (erasedMemberTy->hasTypeVariable()) {
-          RequiresCoercion = true;
-          return Action::Stop;
-        }
-
         return Action::SkipChildren;
       }
 
@@ -2568,7 +2561,6 @@ bool AddExplicitExistentialCoercion::isRequired(
         case RequirementKind::Layout: {
           if (isAnchoredOn(req.getFirstType(), member->getAssocType()))
             return true;
-          
           break;
         }
 
diff --git a/lib/Sema/ConstraintSystem.cpp b/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> {
diff --git a/test/Constraints/opened_existentials.swift b/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>) {
diff --git a/test/decl/protocol/existential_member_accesses_self_assoctype.swift b/test/decl/protocol/existential_member_accesses_self_assoctype.swift
@@ -637,7 +637,6 @@ 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}}
   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}}
@@ -795,14 +794,14 @@ do {
 
     let _: (
       Struct<Bool>, (any ConcreteAssocTypes).Type, () -> Bool
-    ) -> 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}}
+    ) -> any Class<Struct<Bool>.Inner> & ConcreteAssocTypes = arg.method4
 
     let _: (
       Struct<Bool>, (any ConcreteAssocTypes).Type, () -> Bool
     ) -> any Class<Struct<Bool>.Inner> & ConcreteAssocTypes = arg.property4
 
     let _: any Class<Struct<Bool>.Inner> & ConcreteAssocTypes =
-      arg[ // expected-error {{inferred result type 'any Class<Struct<(any ConcreteAssocTypes).A7>.Inner> & ConcreteAssocTypes' requires explicit coercion due to loss of generic requirements}}
+      arg[
         subscript4: Struct<Bool>(), (any ConcreteAssocTypes).self, { true }
       ]
   }
@@ -929,16 +928,14 @@ do {
   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.method5()
   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.method7()
   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>}}
-  
-
+  let _ = exist.method12()
 }
 do {
   let exist: any CovariantAssocTypeErasureDerived

Original file line number	Diff line number	Diff line change
`@@ -3572,7 +3572,7 @@ Type ArchetypeType::getExistentialType() const {`
`3572`	`3572`	`auto interfaceType = getInterfaceType();`
`3573`	`3573`	`auto genericSig = genericEnv->getGenericSignature();`
`3574`	`3574`
`3575`		`- auto upperBound = genericSig->getDependentUpperBounds(interfaceType);`
	`3575`	`+ auto upperBound = genericSig->getNonDependentUpperBounds(interfaceType);`
`3576`	`3576`
`3577`	`3577`	`return genericEnv->mapTypeIntoContext(upperBound);`
`3578`	`3578`	`}`