Merge pull request #75935 from slavapestov/remove-transform

AST: Replace remaining uses of Type::transform() with transformRec()

Author: slavapestov

include/swift/AST/Type.h

@@ -250,16 +250,6 @@ class Type {
   /// its children.
   bool findIf(llvm::function_ref<bool(Type)> pred) const;
 
-  /// Transform the given type by recursively applying the user-provided
-  /// function to each node.
-  ///
-  /// \param fn A function object with the signature \c Type(Type) , which
-  /// accepts a type and returns either a transformed type or a null type
-  /// (which will propagate out the null type).
-  ///
-  /// \returns the result of transforming the type.
-  Type transform(llvm::function_ref<Type(Type)> fn) const;
-
   /// Transform the given type by recursively applying the user-provided
   /// function to each node.
   ///

lib/AST/ASTMangler.cpp

@@ -3723,10 +3723,10 @@ ASTMangler::dropProtocolsFromAssociatedTypes(Type type,
   if (!type->hasDependentMember())
     return type;
 
-  return type.transform([&](Type t) -> Type {
-    if (auto *dmt = dyn_cast<DependentMemberType>(t.getPointer()))
+  return type.transformRec([&](TypeBase *t) -> std::optional<Type> {
+    if (auto *dmt = dyn_cast<DependentMemberType>(t))
       return dropProtocolFromAssociatedType(dmt, sig);
-    return t;
+    return std::nullopt;
   });
 }
 

lib/AST/ASTPrinter.cpp

@@ -6134,11 +6134,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       // FIXME: We need to replace nested existential metatypes so that
       // we don't print duplicate 'any'. This will be unnecessary once
       // ExistentialMetatypeType is split into ExistentialType(MetatypeType).
-      printWithParensIfNotSimple(instanceType.transform([](Type type) -> Type {
-        if (auto existential = type->getAs<ExistentialMetatypeType>())
+      printWithParensIfNotSimple(instanceType.transformRec([](Type t) -> std::optional<Type> {
+        if (auto existential = t->getAs<ExistentialMetatypeType>())
           return MetatypeType::get(existential->getInstanceType());
 
-        return type;
+        return std::nullopt;
       }));
     } else {
       assert(T->is<MetatypeType>());

lib/AST/Decl.cpp

@@ -3477,12 +3477,12 @@ static Type mapSignatureFunctionType(ASTContext &ctx, Type type,
 
 /// Map a type within the signature of a declaration.
 static Type mapSignatureType(ASTContext &ctx, Type type) {
-  return type.transform([&](Type type) -> Type {
+  return type.transformRec([&](Type type) -> std::optional<Type> {
       if (type->is<FunctionType>()) {
         return mapSignatureFunctionType(ctx, type, false, false, false, 1);
       }
 
-      return type;
+      return std::nullopt;
     });
 }
 

lib/AST/DiagnosticEngine.cpp

@@ -613,11 +613,11 @@ static bool isInterestingTypealias(Type type) {
 /// declaration and end up presenting the parameter in τ_0_0 format on
 /// diagnostic.
 static Type getAkaTypeForDisplay(Type type) {
-  return type.transform([](Type visitTy) -> Type {
-    if (isa<SugarType>(visitTy.getPointer()) &&
-        !isa<GenericTypeParamType>(visitTy.getPointer()))
+  return type.transformRec([&](TypeBase *visitTy) -> std::optional<Type> {
+    if (isa<SugarType>(visitTy) &&
+        !isa<GenericTypeParamType>(visitTy))
       return getAkaTypeForDisplay(visitTy->getDesugaredType());
-    return visitTy;
+    return std::nullopt;
   });
 }
 

lib/AST/GenericSignature.cpp

@@ -600,11 +600,11 @@ Type GenericSignatureImpl::getSugaredType(Type type) const {
   if (!type->hasTypeParameter())
     return type;
 
-  return type.transform([this](Type Ty) -> Type {
-    if (auto GP = dyn_cast<GenericTypeParamType>(Ty.getPointer())) {
+  return type.transformRec([this](TypeBase *Ty) -> std::optional<Type> {
+    if (auto GP = dyn_cast<GenericTypeParamType>(Ty)) {
       return Type(getSugaredType(GP));
     }
-    return Ty;
+    return std::nullopt;
   });
 }
 
@@ -1082,8 +1082,10 @@ static Requirement stripBoundDependentMemberTypes(Requirement req) {
   case RequirementKind::Superclass:
   case RequirementKind::SameType:
     return Requirement(req.getKind(), subjectType,
-                       req.getSecondType().transform([](Type t) {
-                         return stripBoundDependentMemberTypes(t);
+                       req.getSecondType().transformRec([](Type t) -> std::optional<Type> {
+                         if (t->isTypeParameter())
+                           return stripBoundDependentMemberTypes(t);
+                         return std::nullopt;
                        }));
 
   case RequirementKind::Layout:

lib/AST/SubstitutionMap.cpp

@@ -593,37 +593,38 @@ SubstitutionMap::combineSubstitutionMaps(SubstitutionMap firstSubMap,
                                          GenericSignature genericSig) {
   auto &ctx = genericSig->getASTContext();
 
-  auto replaceGenericParameter = [&](Type type) -> Type {
+  auto replaceGenericParameter = [&](Type type) -> std::optional<Type> {
     if (auto gp = type->getAs<GenericTypeParamType>()) {
       if (how == CombineSubstitutionMaps::AtDepth) {
         if (gp->getDepth() < firstDepthOrIndex)
           return Type();
-        return GenericTypeParamType::get(gp->isParameterPack(),
-                                         gp->getDepth() + secondDepthOrIndex -
-                                             firstDepthOrIndex,
-                                         gp->getIndex(), ctx);
+        return Type(GenericTypeParamType::get(gp->isParameterPack(),
+                                              gp->getDepth() + secondDepthOrIndex -
+                                                  firstDepthOrIndex,
+                                              gp->getIndex(), ctx));
       }
 
       assert(how == CombineSubstitutionMaps::AtIndex);
       if (gp->getIndex() < firstDepthOrIndex)
         return Type();
-      return GenericTypeParamType::get(
+      return Type(GenericTypeParamType::get(
           gp->isParameterPack(), gp->getDepth(),
-          gp->getIndex() + secondDepthOrIndex - firstDepthOrIndex, ctx);
+          gp->getIndex() + secondDepthOrIndex - firstDepthOrIndex, ctx));
     }
 
-    return type;
+    return std::nullopt;
   };
 
   return get(
     genericSig,
     [&](SubstitutableType *type) {
       if (auto replacement = replaceGenericParameter(type))
-        return Type(replacement).subst(secondSubMap);
+        if (*replacement)
+          return replacement->subst(secondSubMap);
       return Type(type).subst(firstSubMap);
     },
     [&](CanType type, Type substType, ProtocolDecl *proto) {
-      if (auto replacement = type.transform(replaceGenericParameter))
+      if (auto replacement = type.transformRec(replaceGenericParameter))
         return secondSubMap.lookupConformance(replacement->getCanonicalType(),
                                               proto);
       if (auto conformance = firstSubMap.lookupConformance(type, proto))

lib/AST/Type.cpp

@@ -750,10 +750,10 @@ Type TypeBase::getRValueType() {
   if (!hasLValueType())
     return this;
 
-  return Type(this).transform([](Type t) -> Type {
-      if (auto *lvalueTy = dyn_cast<LValueType>(t.getPointer()))
+  return Type(this).transformRec([](TypeBase *t) -> std::optional<Type> {
+      if (auto *lvalueTy = dyn_cast<LValueType>(t))
         return lvalueTy->getObjectType();
-      return t;
+      return std::nullopt;
     });
 }
 
@@ -1863,7 +1863,7 @@ CanType TypeBase::getReducedType(GenericSignature sig) {
 }
 
 CanType TypeBase::getMinimalCanonicalType(const DeclContext *useDC) const {
-  const auto MinimalTy = getCanonicalType().transform([useDC](Type Ty) -> Type {
+  const auto MinimalTy = getCanonicalType().transformRec([useDC](TypeBase *Ty) -> std::optional<Type> {
     const CanType CanTy = CanType(Ty);
 
     if (const auto ET = dyn_cast<ExistentialType>(CanTy)) {
@@ -1899,15 +1899,15 @@ CanType TypeBase::getMinimalCanonicalType(const DeclContext *useDC) const {
       return Composition->getMinimalCanonicalType(useDC);
     }
 
-    return CanTy;
+    return std::nullopt;
   });
 
   return CanType(MinimalTy);
 }
 
 TypeBase *TypeBase::reconstituteSugar(bool Recursive) {
-  auto Func = [Recursive](Type Ty) -> Type {
-    if (auto boundGeneric = dyn_cast<BoundGenericType>(Ty.getPointer())) {
+  auto Func = [Recursive](TypeBase *Ty) -> std::optional<Type> {
+    if (auto boundGeneric = dyn_cast<BoundGenericType>(Ty)) {
 
       auto getGenericArg = [&](unsigned i) -> Type {
         auto arg = boundGeneric->getGenericArgs()[i];
@@ -1917,27 +1917,30 @@ TypeBase *TypeBase::reconstituteSugar(bool Recursive) {
       };
 
       if (boundGeneric->isArray())
-        return ArraySliceType::get(getGenericArg(0));
+        return Type(ArraySliceType::get(getGenericArg(0)));
       if (boundGeneric->isDictionary())
-        return DictionaryType::get(getGenericArg(0), getGenericArg(1));
+        return Type(DictionaryType::get(getGenericArg(0), getGenericArg(1)));
       if (boundGeneric->isOptional())
-        return OptionalType::get(getGenericArg(0));
+        return Type(OptionalType::get(getGenericArg(0)));
     }
-    return Ty;
+    return std::nullopt;
   };
   if (Recursive)
-    return Type(this).transform(Func).getPointer();
-  else
-    return Func(this).getPointer();
+    return Type(this).transformRec(Func).getPointer();
+
+  if (auto result = Func(this))
+    return result->getPointer();
+
+  return this;
 }
 
 TypeBase *TypeBase::getWithoutSyntaxSugar() {
-  auto Func = [](Type Ty) -> Type {
-    if (auto *syntaxSugarType = dyn_cast<SyntaxSugarType>(Ty.getPointer()))
+  auto Func = [](TypeBase *Ty) -> std::optional<Type> {
+    if (auto *syntaxSugarType = dyn_cast<SyntaxSugarType>(Ty))
       return syntaxSugarType->getSinglyDesugaredType()->getWithoutSyntaxSugar();
-    return Ty;
+    return std::nullopt;
   };
-  return Type(this).transform(Func).getPointer();
+  return Type(this).transformRec(Func).getPointer();
 }
 
 #define TYPE(Id, Parent)
@@ -4156,23 +4159,6 @@ static bool transformSILParameter(
   return false;
 }
 
-Type Type::transform(llvm::function_ref<Type(Type)> fn) const {
-  return transformWithPosition(
-      TypePosition::Invariant,
-      [fn](TypeBase *type, auto) -> std::optional<Type> {
-        Type transformed = fn(Type(type));
-        if (!transformed)
-          return Type();
-
-        // If the function didn't change the type at
-        // all, let transformRec() recurse.
-        if (transformed.getPointer() == type)
-          return std::nullopt;
-
-        return transformed;
-      });
-}
-
 static PackType *getTransformedPack(Type substType) {
   if (auto pack = substType->getAs<PackType>()) {
     return pack;

lib/IDE/CompletionLookup.cpp

@@ -574,14 +574,14 @@ Type CompletionLookup::eraseArchetypes(Type type, GenericSignature genericSig) {
         genericFuncType->getExtInfo());
   }
 
-  return type.transform([&](Type t) -> Type {
+  return type.transformRec([&](Type t) -> std::optional<Type> {
     // FIXME: Code completion should only deal with one or the other,
     // and not both.
     if (auto *archetypeType = t->getAs<ArchetypeType>()) {
       // Don't erase opaque archetype.
       if (isa<OpaqueTypeArchetypeType>(archetypeType) &&
           archetypeType->isRoot())
-        return t;
+        return std::nullopt;
 
       auto genericSig = archetypeType->getGenericEnvironment()->getGenericSignature();
       auto upperBound = genericSig->getUpperBound(
@@ -603,7 +603,7 @@ Type CompletionLookup::eraseArchetypes(Type type, GenericSignature genericSig) {
         return upperBound;
     }
 
-    return t;
+    return std::nullopt;
   });
 }
 
@@ -2062,15 +2062,15 @@ void CompletionLookup::onLookupNominalTypeMembers(NominalTypeDecl *NTD,
 }
 
 Type CompletionLookup::normalizeTypeForDuplicationCheck(Type Ty) {
-  return Ty.transform([](Type T) {
+  return Ty.transformRec([](Type T) -> std::optional<Type> {
     if (auto opaque = T->getAs<OpaqueTypeArchetypeType>()) {
       /// Opaque type has a _invisible_ substitution map. Since IDE can't
       /// differentiate them, replace it with empty substitution map.
-      return OpaqueTypeArchetypeType::get(opaque->getDecl(),
-                                          opaque->getInterfaceType(),
-                                          /*Substitutions=*/{});
+      return Type(OpaqueTypeArchetypeType::get(opaque->getDecl(),
+                                               opaque->getInterfaceType(),
+                                               /*Substitutions=*/{}));
     }
-    return T;
+    return std::nullopt;
   });
 }
 

lib/IRGen/GenReflection.cpp

@@ -1473,12 +1473,12 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
 
       // Erase pseudogeneric captures down to AnyObject.
       if (OrigCalleeType->isPseudogeneric()) {
-        SwiftType = SwiftType.transform([&](Type t) -> Type {
+        SwiftType = SwiftType.transformRec([&](Type t) -> std::optional<Type> {
           if (auto *archetype = t->getAs<ArchetypeType>()) {
             assert(archetype->requiresClass() && "don't know what to do");
             return IGM.Context.getAnyObjectType();
           }
-          return t;
+          return std::nullopt;
         })->getCanonicalType();
       }