[Generic Signature] Unify generic upper bound functions

angela-laar · angela-laar · commit 7c16b27c8988 · 2023-05-11T12:04:17.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/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
@@ -360,6 +360,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Determine whether the given dependent type is required to be a class.
   bool requiresClass(Type type) const;
 
+  Type getUpperBound(Type type, bool wantDependentUpperBound = true) const;
+
   /// Determine the superclass bound on the given dependent type.
   Type getSuperclassBound(Type type) const;
 
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
@@ -626,149 +626,41 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
 }
 
 Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
+  return getUpperBound(type);
+}
+
+Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
+  return getUpperBound(type, /*wantNonDependentBound=*/false);
+}
+
+Type GenericSignatureImpl::getUpperBound(Type type,
+                                         bool wantDependentBound) const {
   assert(type->isTypeParameter());
 
   bool hasExplicitAnyObject = requiresClass(type);
 
   llvm::SmallVector<Type, 2> types;
 
-  // Class Inheritence
   // 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>();
-
-      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;
+    while (superclass->hasTypeParameter()) {
+      superclass = getReducedType(superclass);
+      if (wantDependentBound && !superclass->hasTypeParameter()) {
         break;
       }
       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.
-  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 the protocol contains reduced type, erase to it.
+  // Keep going until we hit a type that has no unresolved components.
+  for (auto *proto : getRequiredProtocols(type)) {
     if (proto->requiresClass())
       hasExplicitAnyObject = false;
 
@@ -813,7 +705,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 +715,17 @@ 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);
+    wantDependentBound ? types.push_back(proto->getDeclaredInterfaceType())
+                       : types.push_back(baseType);
   }
 
-  auto constraint = ProtocolCompositionType::get(
-     ctx, types, hasExplicitAnyObject);
+  auto constraint = ProtocolCompositionType::get(getASTContext(), types,
+                                                 hasExplicitAnyObject);
 
   if (!constraint->isConstraintType()) {
     assert(constraint->getClassOrBoundGenericClass());
diff --git a/lib/Sema/CSDiagnostics.cpp b/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();
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.
@@ -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;
         }
 
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
diff --git a/test/SILGen/existential_member_accesses_self_assoctype.swift b/test/SILGen/existential_member_accesses_self_assoctype.swift
diff --git a/test/decl/protocol/existential_member_accesses_self_assoctype.swift b/test/decl/protocol/existential_member_accesses_self_assoctype.swift
