Merge pull request #76051 from slavapestov/archetype-get-parent

AST: Remove ArchetypeType::getParent()

Author: slavapestov

include/swift/AST/InFlightSubstitution.h

@@ -134,6 +134,10 @@ class InFlightSubstitution {
     return Options;
   }
 
+  bool shouldSubstitutePrimaryArchetypes() const {
+    return Options.contains(SubstFlags::SubstitutePrimaryArchetypes);
+  }
+
   bool shouldSubstituteOpaqueArchetypes() const {
     return Options.contains(SubstFlags::SubstituteOpaqueArchetypes);
   }

include/swift/AST/SubstitutionMap.h

@@ -277,7 +277,7 @@ class SubstitutionMap {
   /// Note that this only finds replacements for maps that are directly
   /// stored inside the map. In most cases, you should call Type::subst()
   /// instead, since that will resolve member types also.
-  Type lookupSubstitution(CanSubstitutableType type) const;
+  Type lookupSubstitution(GenericTypeParamType *type) const;
 };
 
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,

include/swift/AST/Type.h

@@ -117,15 +117,13 @@ class MakeAbstractConformanceForGenericType {
 
 /// Flags that can be passed when substituting into a type.
 enum class SubstFlags {
-  /// Allow substitutions to recurse into SILFunctionTypes. Normally,
-  /// SILType::subst() should be used for lowered types, however in special
-  /// cases where the substitution is just changing between contextual and
-  /// interface type representations, using Type::subst() is allowed.
-  AllowLoweredTypes = 0x01,
   /// Map member types to their desugared witness type.
-  DesugarMemberTypes = 0x02,
+  DesugarMemberTypes = 0x01,
+  /// Allow primary archetypes to themselves be the subject of substitution.
+  /// Otherwise, we map them out of context first.
+  SubstitutePrimaryArchetypes = 0x02,
   /// Allow opaque archetypes to themselves be the subject of substitution,
-  /// used when erasing them to their underlying types. otherwise, we
+  /// used when erasing them to their underlying types. Otherwise, we
   /// recursively substitute their substitutions, instead, preserving the
   /// opaque archetype.
   SubstituteOpaqueArchetypes = 0x04,

include/swift/AST/TypeTransform.h

@@ -104,10 +104,6 @@ class TypeTransform {
 case TypeKind::Id:
 #define TYPE(Id, Parent)
 #include "swift/AST/TypeNodes.def"
-    case TypeKind::PrimaryArchetype:
-    case TypeKind::OpenedArchetype:
-    case TypeKind::PackArchetype:
-    case TypeKind::ElementArchetype:
     case TypeKind::Error:
     case TypeKind::Unresolved:
     case TypeKind::TypeVariable:
@@ -117,9 +113,41 @@ case TypeKind::Id:
     case TypeKind::BuiltinTuple:
       return t;
 
+    case TypeKind::PrimaryArchetype:
+    case TypeKind::PackArchetype: {
+      auto *archetype = cast<ArchetypeType>(base);
+      return asDerived().transformPrimaryArchetypeType(archetype, pos);
+    }
+
+    case TypeKind::OpaqueTypeArchetype: {
+      auto *opaque = cast<OpaqueTypeArchetypeType>(base);
+      if (auto result = asDerived().transformOpaqueTypeArchetypeType(opaque, pos))
+        return *result;
+
+      auto subMap = opaque->getSubstitutions();
+      auto newSubMap = asDerived().transformSubMap(subMap);
+      if (newSubMap == subMap)
+        return t;
+      if (!newSubMap)
+        return Type();
+
+      return OpaqueTypeArchetypeType::get(opaque->getDecl(),
+                                          opaque->getInterfaceType(),
+                                          newSubMap);
+    }
+
+    case TypeKind::OpenedArchetype:
+    case TypeKind::ElementArchetype: {
+      auto *local = cast<LocalArchetypeType>(base);
+      if (auto result = asDerived().transformLocalArchetypeType(local, pos))
+        return *result;
+
+      return local;
+    }
+
     case TypeKind::GenericTypeParam: {
       auto *param = cast<GenericTypeParamType>(base);
-      return asDerived().transformGenericTypeParam(param, pos);
+      return asDerived().transformGenericTypeParamType(param, pos);
     }
 
     case TypeKind::Enum:
@@ -140,7 +168,7 @@ case TypeKind::Id:
 
       return t;
     }
-        
+
     case TypeKind::SILBlockStorage: {
       auto storageTy = cast<SILBlockStorageType>(base);
       Type transCap = doIt(storageTy->getCaptureType(),
@@ -194,7 +222,7 @@ case TypeKind::Id:
                               newSubMap);
       return boxTy;
     }
-    
+
     case TypeKind::SILFunction: {
       auto fnTy = cast<SILFunctionType>(base);
 
@@ -356,20 +384,6 @@ case TypeKind::Id:
 
       return BoundGenericType::get(bound->getDecl(), substParentTy, substArgs);
     }
-        
-    case TypeKind::OpaqueTypeArchetype: {
-      auto opaque = cast<OpaqueTypeArchetypeType>(base);
-      auto subMap = opaque->getSubstitutions();
-      auto newSubMap = asDerived().transformSubMap(subMap);
-      if (newSubMap == subMap)
-        return t;
-      if (!newSubMap)
-        return Type();
-
-      return OpaqueTypeArchetypeType::get(opaque->getDecl(),
-                                          opaque->getInterfaceType(),
-                                          newSubMap);
-    }
 
     case TypeKind::ExistentialMetatype: {
       auto meta = cast<ExistentialMetatypeType>(base);
@@ -591,12 +605,12 @@ case TypeKind::Id:
 
     case TypeKind::PackExpansion: {
       auto *expand = cast<PackExpansionType>(base);
-      return asDerived().transformPackExpansion(expand, pos);
+      return asDerived().transformPackExpansionType(expand, pos);
     }
 
     case TypeKind::PackElement: {
       auto element = cast<PackElementType>(base);
-      return asDerived().transformPackElement(element, pos);
+      return asDerived().transformPackElementType(element, pos);
     }
 
     case TypeKind::Tuple: {
@@ -662,7 +676,7 @@ case TypeKind::Id:
 
     case TypeKind::DependentMember: {
       auto dependent = cast<DependentMemberType>(base);
-      return asDerived().transformDependentMember(dependent, pos);
+      return asDerived().transformDependentMemberType(dependent, pos);
     }
 
     case TypeKind::GenericFunction:
@@ -859,7 +873,7 @@ case TypeKind::Id:
       auto objectTy = doIt(inout->getObjectType(), TypePosition::Invariant);
       if (!objectTy || objectTy->hasError())
         return objectTy;
-      
+
       return objectTy.getPointer() == inout->getObjectType().getPointer() ?
         t : InOutType::get(objectTy);
     }
@@ -892,10 +906,10 @@ case TypeKind::Id:
         if (substMember.getPointer() != member.getPointer())
           anyChanged = true;
       }
-      
+
       if (!anyChanged)
         return t;
-      
+
       return ProtocolCompositionType::get(ctx,
                                           substMembers,
                                           pc->getInverses(),
@@ -936,7 +950,7 @@ case TypeKind::Id:
           substArgs);
     }
     }
-    
+
     llvm_unreachable("Unhandled type in transformation");
   }
 
@@ -970,11 +984,11 @@ case TypeKind::Id:
     return doIt(fieldTy, pos)->getCanonicalType();
   }
 
-  Type transformGenericTypeParam(GenericTypeParamType *param, TypePosition pos) {
+  Type transformGenericTypeParamType(GenericTypeParamType *param, TypePosition pos) {
     return param;
   }
 
-  Type transformPackExpansion(PackExpansionType *expand, TypePosition pos) {
+  Type transformPackExpansionType(PackExpansionType *expand, TypePosition pos) {
     // Substitution completely replaces this.
 
     Type transformedPat = doIt(expand->getPatternType(), pos);
@@ -992,7 +1006,7 @@ case TypeKind::Id:
     return PackExpansionType::get(transformedPat, transformedCount);
   }
 
-  Type transformPackElement(PackElementType *element, TypePosition pos) {
+  Type transformPackElementType(PackElementType *element, TypePosition pos) {
     Type transformedPack = doIt(element->getPackType(), pos);
     if (!transformedPack)
       return Type();
@@ -1003,7 +1017,7 @@ case TypeKind::Id:
     return PackElementType::get(transformedPack, element->getLevel());
   }
 
-  Type transformDependentMember(DependentMemberType *dependent, TypePosition pos) {
+  Type transformDependentMemberType(DependentMemberType *dependent, TypePosition pos) {
     auto dependentBase = doIt(dependent->getBase(), pos);
     if (!dependentBase)
       return Type();
@@ -1016,6 +1030,21 @@ case TypeKind::Id:
 
     return DependentMemberType::get(dependentBase, dependent->getName());
   }
+
+  Type transformPrimaryArchetypeType(ArchetypeType *primary,
+                                     TypePosition pos) {
+    return primary;
+  }
+
+  std::optional<Type> transformOpaqueTypeArchetypeType(OpaqueTypeArchetypeType *opaque,
+                                                       TypePosition pos) {
+    return std::nullopt;
+  }
+
+  std::optional<Type> transformLocalArchetypeType(LocalArchetypeType *opaque,
+                                                  TypePosition pos) {
+    return std::nullopt;
+  }
 };
 
 }

include/swift/AST/Types.h

@@ -4803,8 +4803,7 @@ class SILFunctionConventions;
 
 
 CanType substOpaqueTypesWithUnderlyingTypes(CanType type,
-                                            TypeExpansionContext context,
-                                            bool allowLoweredTypes = false);
+                                            TypeExpansionContext context);
 ProtocolConformanceRef
 substOpaqueTypesWithUnderlyingTypes(ProtocolConformanceRef ref, Type origType,
                                     TypeExpansionContext context);
@@ -6575,10 +6574,6 @@ class ArchetypeType : public SubstitutableType,
   /// which the archetype conforms.
   Type getNestedTypeByName(Identifier name);
 
-  /// Retrieve the parent of this archetype, or null if this is a
-  /// primary archetype.
-  ArchetypeType *getParent() const;
-
   /// Return the archetype that represents the root generic parameter of its
   /// interface type.
   ArchetypeType *getRoot() const;