Merge pull request swiftlang#75947 from slavapestov/type-subst-rework-2

Type::subst() rework, part 2

Author: slavapestov

include/swift/AST/InFlightSubstitution.h

@@ -138,6 +138,10 @@ class InFlightSubstitution {
     return Options.contains(SubstFlags::SubstituteOpaqueArchetypes);
   }
 
+  bool shouldSubstituteLocalArchetypes() const {
+    return Options.contains(SubstFlags::SubstituteLocalArchetypes);
+  }
+
   /// Is the given type invariant to substitution?
   bool isInvariant(Type type) const;
 };

include/swift/AST/SubstitutionMap.h

@@ -34,6 +34,7 @@ namespace swift {
 
 class GenericEnvironment;
 class GenericParamList;
+class RecursiveTypeProperties;
 class SubstitutableType;
 typedef CanTypeWrapper<GenericTypeParamType> CanGenericTypeParamType;
 
@@ -150,19 +151,7 @@ class SubstitutionMap {
   /// parameters.
   ArrayRef<Type> getInnermostReplacementTypes() const;
 
-  /// Query whether any replacement types in the map contain archetypes.
-  bool hasArchetypes() const;
-
-  /// Query whether any replacement types in the map contain an opened
-  /// existential or opened element.
-  bool hasLocalArchetypes() const;
-
-  /// Query whether any replacement types in the map contain an opaque
-  /// return type.
-  bool hasOpaqueArchetypes() const;
-
-  /// Query whether any replacement types in the map contain dynamic Self.
-  bool hasDynamicSelf() const;
+  RecursiveTypeProperties getRecursiveProperties() const;
 
   /// Whether the replacement types are all canonical.
   bool isCanonical() const;

include/swift/AST/Type.h

@@ -117,20 +117,24 @@ 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.
+  /// 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,
-  /// Substitute types involving opaque type archetypes.
+  /// Allow opaque archetypes to themselves be the subject of substitution,
+  /// used when erasing them to their underlying types. otherwise, we
+  /// recursively substitute their substitutions, instead, preserving the
+  /// opaque archetype.
   SubstituteOpaqueArchetypes = 0x04,
+  /// Allow local archetypes to themselves be the subject of substitution.
+  SubstituteLocalArchetypes = 0x08,
   /// Don't increase pack expansion level for free pack references.
   /// Do not introduce new usages of this flag.
   /// FIXME: Remove this.
-  PreservePackExpansionLevel = 0x08,
+  PreservePackExpansionLevel = 0x10,
 };
 
 /// Options for performing substitutions into a type.

include/swift/AST/TypeTransform.h

@@ -112,12 +112,16 @@ case TypeKind::Id:
     case TypeKind::Unresolved:
     case TypeKind::TypeVariable:
     case TypeKind::Placeholder:
-    case TypeKind::GenericTypeParam:
     case TypeKind::SILToken:
     case TypeKind::Module:
     case TypeKind::BuiltinTuple:
       return t;
 
+    case TypeKind::GenericTypeParam: {
+      auto *param = cast<GenericTypeParamType>(base);
+      return asDerived().transformGenericTypeParam(param, pos);
+    }
+
     case TypeKind::Enum:
     case TypeKind::Struct:
     case TypeKind::Class:
@@ -164,64 +168,50 @@ case TypeKind::Id:
     case TypeKind::SILBox: {
       bool changed = false;
       auto boxTy = cast<SILBoxType>(base);
-  #ifndef NDEBUG
-      // This interface isn't suitable for updating the substitution map in a
-      // generic SILBox.
-      for (Type type : boxTy->getSubstitutions().getReplacementTypes()) {
-        assert(type->isEqual(
-                   doIt(type, TypePosition::Invariant)) &&
-               "SILBoxType substitutions can't be transformed");
-      }
-  #endif
+
       SmallVector<SILField, 4> newFields;
       auto *l = boxTy->getLayout();
       for (auto f : l->getFields()) {
         auto fieldTy = f.getLoweredType();
-        auto transformed = doIt(fieldTy, TypePosition::Invariant)
-                ->getCanonicalType();
+        auto transformed = asDerived().transformSILField(
+          fieldTy, TypePosition::Invariant);
         changed |= fieldTy != transformed;
         newFields.push_back(SILField(transformed, f.isMutable()));
       }
+
+      auto oldSubMap = boxTy->getSubstitutions();
+      auto newSubMap = asDerived().transformSubMap(oldSubMap);
+      if (oldSubMap && !newSubMap)
+        return Type();
+      changed |= (oldSubMap != newSubMap);
       if (!changed)
         return t;
       boxTy = SILBoxType::get(ctx,
                               SILLayout::get(ctx,
                                              l->getGenericSignature(),
                                              newFields,
                                              l->capturesGenericEnvironment()),
-                              boxTy->getSubstitutions());
+                              newSubMap);
       return boxTy;
     }
 
     case TypeKind::SILFunction: {
       auto fnTy = cast<SILFunctionType>(base);
-      bool changed = false;
-      auto updateSubs = [&](SubstitutionMap &subs) -> bool {
-        // This interface isn't suitable for doing most transformations on
-        // a substituted SILFunctionType, but it's too hard to come up with
-        // an assertion that meaningfully captures what restrictions are in
-        // place.  Generally the restriction that you can't naively substitute
-        // a SILFunctionType using AST mechanisms will have to be good enough.
-        SmallVector<Type, 4> newReplacements;
-        for (Type type : subs.getReplacementTypes()) {
-          auto transformed = doIt(type, TypePosition::Invariant);
-          newReplacements.push_back(transformed->getCanonicalType());
-          if (!type->isEqual(transformed))
-            changed = true;
-        }
-
-        if (changed) {
-          subs = SubstitutionMap::get(subs.getGenericSignature(),
-                                      newReplacements,
-                                      subs.getConformances());
-        }
-
-        return changed;
-      };
 
       if (fnTy->isPolymorphic())
         return fnTy;
 
+      auto updateSubs = [&](SubstitutionMap &subs) -> bool {
+        auto newSubs = asDerived().transformSubMap(subs);
+        if (subs && !newSubs)
+          return false;
+        if (subs == newSubs)
+          return false;
+
+        subs = newSubs;
+        return true;
+      };
+
       if (auto subs = fnTy->getInvocationSubstitutions()) {
         if (updateSubs(subs)) {
           return fnTy->withInvocationSubstitutions(subs);
@@ -236,6 +226,8 @@ case TypeKind::Id:
         return fnTy;
       }
 
+      bool changed = false;
+
       SmallVector<SILParameterInfo, 8> transInterfaceParams;
       for (SILParameterInfo param : fnTy->getParameters()) {
         if (transformSILParameter(pos.flipped(), param, changed))
@@ -433,23 +425,28 @@ case TypeKind::Id:
         if (!newParentType) return newUnderlyingTy;
       }
 
-      auto subMap = alias->getSubstitutionMap();
-      for (Type oldReplacementType : subMap.getReplacementTypes()) {
-        Type newReplacementType = doIt(oldReplacementType, TypePosition::Invariant);
-        if (!newReplacementType)
-          return newUnderlyingTy;
+      if (newParentType && newParentType->isExistentialType())
+        return newUnderlyingTy;
 
-        // If anything changed with the replacement type, we lose the sugar.
-        // FIXME: This is really unfortunate.
-        if (newReplacementType.getPointer() != oldReplacementType.getPointer())
-          return newUnderlyingTy;
-      }
+      auto oldSubMap = alias->getSubstitutionMap();
+      auto newSubMap = asDerived().transformSubMap(oldSubMap);
+      if (oldSubMap && !newSubMap)
+        return Type();
 
       if (oldParentType.getPointer() == newParentType.getPointer() &&
-          oldUnderlyingTy.getPointer() == newUnderlyingTy.getPointer())
+          oldUnderlyingTy.getPointer() == newUnderlyingTy.getPointer() &&
+          oldSubMap == newSubMap)
         return t;
 
-      return TypeAliasType::get(alias->getDecl(), newParentType, subMap,
+      // Don't leave local archetypes and type variables behind in sugar
+      // if they don't appear in the underlying type, to avoid confusion.
+      auto props = newSubMap.getRecursiveProperties();
+      if (props.hasLocalArchetype() && !newUnderlyingTy->hasLocalArchetype())
+        return newUnderlyingTy;
+      if (props.hasTypeVariable() && !newUnderlyingTy->hasTypeVariable())
+        return newUnderlyingTy;
+
+      return TypeAliasType::get(alias->getDecl(), newParentType, newSubMap,
                                 newUnderlyingTy);
     }
 
@@ -593,43 +590,13 @@ case TypeKind::Id:
     }
 
     case TypeKind::PackExpansion: {
-      auto expand = cast<PackExpansionType>(base);
-
-      // Substitution completely replaces this.
-
-      Type transformedPat = doIt(expand->getPatternType(), pos);
-      if (!transformedPat)
-        return Type();
-
-      Type transformedCount = doIt(expand->getCountType(), TypePosition::Shape);
-      if (!transformedCount)
-        return Type();
-
-      if (transformedPat.getPointer() == expand->getPatternType().getPointer() &&
-          transformedCount.getPointer() == expand->getCountType().getPointer())
-        return t;
-
-      // // If we transform the count to a pack type, expand the pattern.
-      // // This is necessary because of how we piece together types in
-      // // the constraint system.
-      // if (auto countPack = transformedCount->getAs<PackType>()) {
-      //   return PackExpansionType::expand(transformedPat, countPack);
-      // }
-
-      return PackExpansionType::get(transformedPat, transformedCount);
+      auto *expand = cast<PackExpansionType>(base);
+      return asDerived().transformPackExpansion(expand, pos);
     }
 
     case TypeKind::PackElement: {
       auto element = cast<PackElementType>(base);
-
-      Type transformedPack = doIt(element->getPackType(), pos);
-      if (!transformedPack)
-        return Type();
-
-      if (transformedPack.getPointer() == element->getPackType().getPointer())
-        return t;
-
-      return PackElementType::get(transformedPack, element->getLevel());
+      return asDerived().transformPackElement(element, pos);
     }
 
     case TypeKind::Tuple: {
@@ -695,17 +662,7 @@ case TypeKind::Id:
 
     case TypeKind::DependentMember: {
       auto dependent = cast<DependentMemberType>(base);
-      auto dependentBase = doIt(dependent->getBase(), pos);
-      if (!dependentBase)
-        return Type();
-
-      if (dependentBase.getPointer() == dependent->getBase().getPointer())
-        return t;
-
-      if (auto assocType = dependent->getAssocType())
-        return DependentMemberType::get(dependentBase, assocType);
-
-      return DependentMemberType::get(dependentBase, dependent->getName());
+      return asDerived().transformDependentMember(dependent, pos);
     }
 
     case TypeKind::GenericFunction:
@@ -1008,8 +965,59 @@ case TypeKind::Id:
         QueryReplacementTypeArray{sig, newSubs},
         LookUpConformanceInModule());
   }
+
+  CanType transformSILField(CanType fieldTy, TypePosition pos) {
+    return doIt(fieldTy, pos)->getCanonicalType();
+  }
+
+  Type transformGenericTypeParam(GenericTypeParamType *param, TypePosition pos) {
+    return param;
+  }
+
+  Type transformPackExpansion(PackExpansionType *expand, TypePosition pos) {
+    // Substitution completely replaces this.
+
+    Type transformedPat = doIt(expand->getPatternType(), pos);
+    if (!transformedPat)
+      return Type();
+
+    Type transformedCount = doIt(expand->getCountType(), TypePosition::Shape);
+    if (!transformedCount)
+      return Type();
+
+    if (transformedPat.getPointer() == expand->getPatternType().getPointer() &&
+        transformedCount.getPointer() == expand->getCountType().getPointer())
+      return expand;
+
+    return PackExpansionType::get(transformedPat, transformedCount);
+  }
+
+  Type transformPackElement(PackElementType *element, TypePosition pos) {
+    Type transformedPack = doIt(element->getPackType(), pos);
+    if (!transformedPack)
+      return Type();
+
+    if (transformedPack.getPointer() == element->getPackType().getPointer())
+      return element;
+
+    return PackElementType::get(transformedPack, element->getLevel());
+  }
+
+  Type transformDependentMember(DependentMemberType *dependent, TypePosition pos) {
+    auto dependentBase = doIt(dependent->getBase(), pos);
+    if (!dependentBase)
+      return Type();
+
+    if (dependentBase.getPointer() == dependent->getBase().getPointer())
+      return dependent;
+
+    if (auto assocType = dependent->getAssocType())
+      return DependentMemberType::get(dependentBase, assocType);
+
+    return DependentMemberType::get(dependentBase, dependent->getName());
+  }
 };
 
 }
 
-#endif
+#endif

include/swift/AST/Types.h

@@ -246,6 +246,11 @@ class RecursiveTypeProperties {
   /// they have a type variable originator.
   bool isSolverAllocated() const { return Bits & SolverAllocated; }
 
+  /// Determine whether the type involves a primary, pack or local archetype.
+  bool hasArchetype() const {
+    return hasPrimaryArchetype() || hasLocalArchetype();
+  }
+
   /// Does a type with these properties structurally contain a local
   /// archetype?
   bool hasLocalArchetype() const {
@@ -720,10 +725,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
   }
 
   /// Determine whether the type involves a primary, pack or local archetype.
-  ///
-  /// FIXME: Replace all remaining callers with a more precise check.
   bool hasArchetype() const {
-    return hasPrimaryArchetype() || hasLocalArchetype();
+    return getRecursiveProperties().hasArchetype();
   }
 
   /// Determine whether the type involves an opened existential archetype.
@@ -780,10 +783,6 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// Determine whether the type is an opened existential type with Error inside
   bool isOpenedExistentialWithError();
 
-  /// Retrieve the set of root opened archetypes that occur within this type.
-  void getRootOpenedExistentials(
-      SmallVectorImpl<OpenedArchetypeType *> &rootOpenedArchetypes) const;
-
   /// Retrieve the set of type parameter packs that occur within this type.
   void getTypeParameterPacks(SmallVectorImpl<Type> &rootParameterPacks);