Merge pull request #69950 from slavapestov/clean-up-open-existentials

Cleanups and fixes for opened existentials

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -7364,16 +7364,6 @@ WARNING(backdeployed_opaque_result_not_supported,none,
 // MARK: Implicit opening of existential types
 //------------------------------------------------------------------------------
 
-ERROR(result_requires_explicit_coercion,none,
-      "inferred result type %0 requires explicit coercion due to "
-      "loss of generic requirements",
-      (Type))
-
-NOTE(candidate_result_requires_explicit_coercion,none,
-     "inferred result type %0 requires explicit coercion due to "
-     "loss of generic requirements",
-     (Type))
-
 ERROR(concurrency_task_to_thread_model_custom_executor,none,
       "custom executors are not permitted within %0", (StringRef))
 ERROR(concurrency_task_to_thread_model_async_main,none,

include/swift/AST/GenericSignature.h

@@ -362,8 +362,6 @@ 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 = false) const;
-
   /// Determine the superclass bound on the given dependent type.
   Type getSuperclassBound(Type type) const;
 
@@ -457,19 +455,12 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// generic parameter types by their sugared form.
   Type getSugaredType(Type type) const;
 
-  /// Given a type parameter, compute the most specific supertype (upper bound)
-  /// that is not dependent on other type parameters.
-  ///
-  /// \note If the upper bound is a protocol or protocol composition,
-  /// will return an instance of \c ExistentialType.
-  Type getNonDependentUpperBounds(Type type) const;
-
-  /// Given a type parameter, compute the most specific supertype (upper bound)
-  /// that is possibly dependent on other type parameters.
+  /// Given a type parameter, compute the most specific supertype (upper bound),
+  /// possibly dependent on other type parameters.
   ///
   /// \note If the upper bound is a protocol or protocol composition,
   /// will return an instance of \c ExistentialType.
-  Type getDependentUpperBounds(Type type) const;
+  Type getUpperBound(Type type) const;
 
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<GenericTypeParamType *> genericParams,

include/swift/AST/Types.h

@@ -757,11 +757,6 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Retrieve the set of type parameter packs that occur within this type.
   void walkPackReferences(llvm::function_ref<bool (Type)> fn);
 
-  /// Replace opened archetypes with the given root with their most
-  /// specific non-dependent upper bounds throughout this type.
-  Type typeEraseOpenedArchetypesWithRoot(const OpenedArchetypeType *root,
-                                         const DeclContext *useDC) const;
-
   /// Given a declaration context, returns a function type with the 'self'
   /// type curried as the input if the declaration context describes a type.
   /// Otherwise, returns the type itself.

include/swift/Sema/CSFix.h

@@ -3410,40 +3410,6 @@ class IgnoreDefaultExprTypeMismatch : public AllowArgumentMismatch {
   }
 };
 
-class AddExplicitExistentialCoercion final : public ConstraintFix {
-  Type ErasedResultType;
-
-  AddExplicitExistentialCoercion(ConstraintSystem &cs, Type erasedResultTy,
-                                 ConstraintLocator *locator,
-                                 FixBehavior fixBehavior)
-      : ConstraintFix(cs, FixKind::AddExplicitExistentialCoercion, locator,
-                      fixBehavior),
-        ErasedResultType(erasedResultTy) {}
-
-public:
-  std::string getName() const override {
-    return "add explicit existential type coercion";
-  }
-
-  bool diagnose(const Solution &solution, bool asNote = false) const override;
-
-  static bool
-  isRequired(ConstraintSystem &cs, Type resultTy,
-             ArrayRef<std::pair<TypeVariableType *, OpenedArchetypeType *>>
-                 openedExistentials,
-             ConstraintLocatorBuilder locator);
-
-  static bool
-  isRequired(ConstraintSystem &cs, Type resultTy,
-             llvm::function_ref<llvm::Optional<Type>(TypeVariableType *)>
-                 findExistentialType,
-             ConstraintLocatorBuilder locator);
-
-  static AddExplicitExistentialCoercion *create(ConstraintSystem &cs,
-                                                Type resultTy,
-                                                ConstraintLocator *locator);
-};
-
 class RenameConflictingPatternVariables final
     : public ConstraintFix,
       private llvm::TrailingObjects<RenameConflictingPatternVariables,

include/swift/Sema/ConstraintSystem.h

@@ -5770,12 +5770,19 @@ llvm::Optional<MatchCallArgumentResult> matchCallArguments(
 Expr *getArgumentLabelTargetExpr(Expr *fn);
 
 /// Given a type that includes an existential type that has been opened to
-/// the given type variable, type-erase occurrences of that opened type
-/// variable and anything that depends on it to their non-dependent bounds.
+/// the given type variable, replace the opened type variable and its member
+/// types with their upper bounds.
 Type typeEraseOpenedExistentialReference(Type type, Type existentialBaseType,
                                          TypeVariableType *openedTypeVar,
                                          TypePosition outermostPosition);
 
+
+/// Given a type that includes opened existential archetypes derived from
+/// the given generic environment, replace the archetypes with their upper
+/// bounds.
+Type typeEraseOpenedArchetypesWithRoot(Type type,
+                                       const OpenedArchetypeType *root);
+
 /// 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

@@ -635,26 +635,23 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
   return GenericParamKey(param).findIndexIn(getGenericParams());
 }
 
-Type GenericSignatureImpl::getNonDependentUpperBounds(Type type) const {
-  return getUpperBound(type);
-}
-
-Type GenericSignatureImpl::getDependentUpperBounds(Type type) const {
-  return getUpperBound(type, /*wantDependentBound=*/true);
-}
-
-Type GenericSignatureImpl::getUpperBound(Type type,
-                                         bool wantDependentBound) const {
+Type GenericSignatureImpl::getUpperBound(Type type) const {
   assert(type->isTypeParameter());
 
-  bool hasExplicitAnyObject = requiresClass(type);
-
   llvm::SmallVector<Type, 2> types;
+  unsigned rootDepth = type->getRootGenericParam()->getDepth();
+
+  bool hasExplicitAnyObject = requiresClass(type);
 
   if (Type superclass = getSuperclassBound(type)) {
     do {
       superclass = getReducedType(superclass);
-      if (wantDependentBound || !superclass->hasTypeParameter()) {
+
+      if (!superclass.findIf([&](Type t) {
+            if (auto *paramTy = t->getAs<GenericTypeParamType>())
+              return (paramTy->getDepth() == rootDepth);
+            return false;
+          })) {
         break;
       }
     } while ((superclass = superclass->getSuperclass()));
@@ -684,31 +681,13 @@ Type GenericSignatureImpl::getUpperBound(Type type,
 
         // 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 && (wantDependentBound || !hasOuterGenericParam))
+        if (!reducedType.findIf([&](Type t) {
+            if (auto *paramTy = t->getAs<GenericTypeParamType>())
+              return (paramTy->getDepth() == rootDepth);
+            return false;
+          })) {
           argTypes.push_back(reducedType);
+        }
       }
 
       // If we have constrained all primary associated types, create a
@@ -721,7 +700,8 @@ Type GenericSignatureImpl::getUpperBound(Type type,
       //
       // In that case just add the base type in the default branch below.
       if (argTypes.size() == primaryAssocTypes.size()) {
-        types.push_back(ParameterizedProtocolType::get(getASTContext(), baseType, argTypes));
+        types.push_back(ParameterizedProtocolType::get(
+            getASTContext(), baseType, argTypes));
         continue;
       }
     }

lib/AST/Type.cpp

@@ -606,83 +606,6 @@ void TypeBase::getRootOpenedExistentials(
   });
 }
 
-Type TypeBase::typeEraseOpenedArchetypesWithRoot(
-    const OpenedArchetypeType *root, const DeclContext *useDC) const {
-  assert(root->isRoot() && "Expected a root archetype");
-
-  Type type = Type(const_cast<TypeBase *>(this));
-  if (!hasOpenedExistential())
-    return type;
-
-  const auto sig = root->getASTContext().getOpenedExistentialSignature(
-      root->getExistentialType(), useDC->getGenericSignatureOfContext());
-
-  unsigned metatypeDepth = 0;
-
-  std::function<Type(Type)> transformFn;
-  transformFn = [&](Type type) -> Type {
-    return type.transformRec([&](TypeBase *ty) -> llvm::Optional<Type> {
-      // Don't recurse into children unless we have to.
-      if (!ty->hasOpenedExistential())
-        return Type(ty);
-
-      if (isa<MetatypeType>(ty)) {
-        const auto instanceTy = ty->getMetatypeInstanceType();
-        ++metatypeDepth;
-        const auto erasedTy = transformFn(instanceTy);
-        --metatypeDepth;
-
-        if (instanceTy.getPointer() == erasedTy.getPointer()) {
-          return Type(ty);
-        }
-
-        return Type(ExistentialMetatypeType::get(erasedTy));
-      }
-
-      // Opaque types whose substitutions involve this type parameter are
-      // erased to their upper bound.
-      if (auto opaque = dyn_cast<OpaqueTypeArchetypeType>(ty)) {
-        for (auto replacementType :
-                 opaque->getSubstitutions().getReplacementTypes()) {
-          if (replacementType->hasOpenedExistentialWithRoot(root)) {
-            Type interfaceType = opaque->getInterfaceType();
-            auto genericSig =
-                opaque->getDecl()->getOpaqueInterfaceGenericSignature();
-            return genericSig->getNonDependentUpperBounds(interfaceType);
-          }
-        }
-      }
-
-      auto *const archetype = dyn_cast<OpenedArchetypeType>(ty);
-      if (!archetype) {
-        // Recurse.
-        return llvm::None;
-      }
-
-      if (!root->isEqual(archetype->getRoot())) {
-        return Type(ty);
-      }
-
-      Type erasedTy;
-      if (root->isEqual(archetype)) {
-        erasedTy = root->getExistentialType();
-      } else {
-        erasedTy =
-            sig->getNonDependentUpperBounds(archetype->getInterfaceType());
-      }
-
-      if (metatypeDepth) {
-        if (const auto existential = erasedTy->getAs<ExistentialType>())
-          return existential->getConstraintType();
-      }
-
-      return erasedTy;
-    });
-  };
-
-  return transformFn(type);
-}
-
 Type TypeBase::addCurriedSelfType(const DeclContext *dc) {
   if (!dc->isTypeContext())
     return this;
@@ -3681,7 +3604,7 @@ Type ArchetypeType::getExistentialType() const {
   auto interfaceType = getInterfaceType();
   auto genericSig = genericEnv->getGenericSignature();
 
-  auto upperBound = genericSig->getDependentUpperBounds(interfaceType);
+  auto upperBound = genericSig->getUpperBound(interfaceType);
 
   return genericEnv->mapTypeIntoContext(upperBound);
 }

lib/Sema/CSApply.cpp

@@ -880,8 +880,8 @@ namespace {
       Type resultTy;
       resultTy = cs.getType(result);
       if (resultTy->hasOpenedExistentialWithRoot(record.Archetype)) {
-        Type erasedTy = resultTy->typeEraseOpenedArchetypesWithRoot(
-            record.Archetype, dc);
+        Type erasedTy = constraints::typeEraseOpenedArchetypesWithRoot(
+            resultTy, record.Archetype);
         auto range = result->getSourceRange();
         result = coerceToType(result, erasedTy, locator);
         // FIXME: Implement missing tuple-to-tuple conversion
@@ -1590,8 +1590,8 @@ namespace {
         } else {
           // Erase opened existentials from the type of the thunk; we're
           // going to open the existential inside the thunk's body.
-          containerTy = containerTy->typeEraseOpenedArchetypesWithRoot(
-              knownOpened->second, dc);
+          containerTy = constraints::typeEraseOpenedArchetypesWithRoot(
+              containerTy, knownOpened->second);
           selfTy = containerTy;
         }
       }
@@ -1673,8 +1673,8 @@ namespace {
           // If the base was an opened existential, erase the opened
           // existential.
           if (openedExistential) {
-            refType = refType->typeEraseOpenedArchetypesWithRoot(
-                baseTy->castTo<OpenedArchetypeType>(), dc);
+            refType = constraints::typeEraseOpenedArchetypesWithRoot(
+                refType, baseTy->castTo<OpenedArchetypeType>());
           }
 
           return refType;
@@ -1884,8 +1884,8 @@ namespace {
               getConstraintSystem().getConstraintLocator(memberLocator));
           if (knownOpened != solution.OpenedExistentialTypes.end()) {
             curryThunkTy =
-                curryThunkTy
-                    ->typeEraseOpenedArchetypesWithRoot(knownOpened->second, dc)
+                constraints::typeEraseOpenedArchetypesWithRoot(
+                  curryThunkTy, knownOpened->second)
                     ->castTo<FunctionType>();
           }
         }