Merge pull request #64464 from rjmccall/pack-argument-reabstraction

A myriad of fixes, including the reabstraction of pack argument values

Author: rjmccall

include/swift/SIL/AbstractionPattern.h

@@ -915,7 +915,7 @@ class AbstractionPattern {
     // don't want to try to unique by Clang node.
     //
     // Even if we support Clang nodes someday, we *cannot* cache
-    // by the open-coded patterns like Tuple and PackExpansion.
+    // by the open-coded patterns like Tuple.
     return getKind() == Kind::Type || getKind() == Kind::Opaque
         || getKind() == Kind::Discard;
   }
@@ -980,7 +980,8 @@ class AbstractionPattern {
     case Kind::Type:
     case Kind::ClangType:
     case Kind::Discard: {
-      return getType()->isParameterPack();
+      auto ty = getType();
+      return isa<PackArchetypeType>(ty) || ty->isParameterPack();
     }
     default:
       return false;
@@ -1470,6 +1471,18 @@ class AbstractionPattern {
   AbstractionPattern getPackExpansionComponentType(CanType substType) const;
   AbstractionPattern getPackExpansionComponentType(bool isExpansion) const;
 
+  /// Given that the value being abstracted is a metatype type, return
+  /// the abstraction pattern for its instance type.
+  AbstractionPattern getMetatypeInstanceType() const;
+
+  /// Given that the value being abstracted is a dynamic self type, return
+  /// the abstraction pattern for its self type.
+  AbstractionPattern getDynamicSelfSelfType() const;
+
+  /// Given that the value being abstracted is a parameterized protocol
+  /// type, return the abstraction pattern for one of its argument types.
+  AbstractionPattern getParameterizedProtocolArgType(unsigned i) const;
+
   /// Given that the value being abstracted is a function, return the
   /// abstraction pattern for its result type.
   AbstractionPattern getFunctionResultType() const;

lib/AST/SubstitutionMap.cpp

@@ -458,6 +458,8 @@ SubstitutionMap SubstitutionMap::subst(TypeSubstitutionFn subs,
       continue;
     }
     newSubs.push_back(type.subst(subs, conformances, options));
+    assert(type->is<PackType>() == newSubs.back()->is<PackType>() &&
+           "substitution changed the pack-ness of a replacement type");
   }
 
   SmallVector<ProtocolConformanceRef, 4> newConformances;

lib/AST/Type.cpp

@@ -5311,28 +5311,16 @@ case TypeKind::Id:
   case TypeKind::SILFunction: {
     auto fnTy = cast<SILFunctionType>(base);
     bool changed = false;
-    auto hasTypeErasedGenericClassType = [](Type ty) -> bool {
-      return ty.findIf([](Type subType) -> bool {
-        if (subType->isTypeErasedGenericClassType())
-          return true;
-        else
-          return false;
-      });
-    };
     auto updateSubs = [&](SubstitutionMap &subs) -> bool {
-      // This interface isn't suitable for updating the substitution map in a
-      // substituted SILFunctionType.
-      // TODO(SILFunctionType): Is it suitable for any SILFunctionType??
+      // 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 =
             type.transformWithPosition(TypePosition::Invariant, fn);
-        assert((type->isEqual(transformed) ||
-                (type->hasTypeParameter() && transformed->hasTypeParameter()) ||
-                (hasTypeErasedGenericClassType(type) &&
-                 hasTypeErasedGenericClassType(transformed))) &&
-               "Substituted SILFunctionType can't be transformed into a "
-               "concrete type");
         newReplacements.push_back(transformed->getCanonicalType());
         if (!type->isEqual(transformed))
           changed = true;