AST: Use PackElementType to model references to pack elements of outer expansions

Author: slavapestov

include/swift/AST/InFlightSubstitution.h

@@ -49,27 +49,15 @@ class InFlightSubstitution {
   InFlightSubstitution(const InFlightSubstitution &) = delete;
   InFlightSubstitution &operator=(const InFlightSubstitution &) = delete;
 
-  // TODO: when we add PackElementType, we should recognize it during
-  // substitution and either call different methods on this class or
-  // pass an extra argument for the pack-expansion depth D.  We should
-  // be able to rely on that to mark a pack-element reference instead
-  // of checking whether the original type was a pack.  Substitution
-  // should use the D'th entry from the end of ActivePackExpansions to
-  // guide the element substitution:
-  //   - project the given index of the pack substitution
-  //   - wrap it in a PackElementType if it's a subst expansion
-  //   - the depth of that PackElementType is the number of subst
-  //     expansions between the depth entry and the end of
-  //     ActivePackExpansions
-
   /// Perform primitive substitution on the given type.  Returns Type()
   /// if the type should not be substituted as a whole.
-  Type substType(SubstitutableType *origType);
+  Type substType(SubstitutableType *origType, unsigned level);
 
   /// Perform primitive conformance lookup on the given type.
   ProtocolConformanceRef lookupConformance(CanType dependentType,
                                            Type conformingReplacementType,
-                                           ProtocolDecl *conformedProtocol);
+                                           ProtocolDecl *conformedProtocol,
+                                           unsigned level);
 
   /// Given the shape type of a pack expansion, invoke the given callback
   /// for each expanded component of it.  If the substituted component

include/swift/AST/Type.h

@@ -151,7 +151,11 @@ enum class SubstFlags {
   /// Map member types to their desugared witness type.
   DesugarMemberTypes = 0x02,
   /// Substitute types involving opaque type archetypes.
-  SubstituteOpaqueArchetypes = 0x04
+  SubstituteOpaqueArchetypes = 0x04,
+  /// Don't increase pack expansion level for free pack references.
+  /// Do not introduce new usages of this flag.
+  /// FIXME: Remove this.
+  PreservePackExpansionLevel = 0x08,
 };
 
 /// Options for performing substitutions into a type.

lib/AST/ASTMangler.cpp

@@ -659,7 +659,8 @@ static Type getTypeForDWARFMangling(Type t) {
       return t;
     },
     MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes);
+    SubstFlags::AllowLoweredTypes |
+    SubstFlags::PreservePackExpansionLevel);
 }
 
 std::string ASTMangler::mangleTypeForDebugger(Type Ty, GenericSignature sig) {

lib/AST/GenericEnvironment.cpp

@@ -432,7 +432,8 @@ Type TypeBase::mapTypeOutOfContext() {
   assert(!hasTypeParameter() && "already have an interface type");
   return Type(this).subst(MapTypeOutOfContext(),
     MakeAbstractConformanceForGenericType(),
-    SubstFlags::AllowLoweredTypes);
+    SubstFlags::AllowLoweredTypes |
+    SubstFlags::PreservePackExpansionLevel);
 }
 
 class GenericEnvironment::NestedTypeStorage
@@ -637,7 +638,8 @@ Type GenericEnvironment::mapTypeIntoContext(
   type = maybeApplyOuterContextSubstitutions(type);
   Type result = type.subst(QueryInterfaceTypeSubstitutions(this),
                            lookupConformance,
-                           SubstFlags::AllowLoweredTypes);
+                           SubstFlags::AllowLoweredTypes |
+                           SubstFlags::PreservePackExpansionLevel);
   assert((!result->hasTypeParameter() || result->hasError() ||
           getKind() == Kind::Opaque) &&
          "not fully substituted");
@@ -787,16 +789,19 @@ GenericEnvironment::mapElementTypeIntoPackContext(Type type) const {
   // Map element archetypes to the pack archetypes by converting
   // element types to interface types and adding the isParameterPack
   // bit. Then, map type parameters to archetypes.
-  return type.subst([&](SubstitutableType *type) {
-    auto *genericParam = type->getAs<GenericTypeParamType>();
-    if (!genericParam)
-      return Type();
-
-    if (auto *packParam = packParamForElement[{genericParam}])
-      return substitutions(packParam);
-
-    return substitutions(genericParam);
-  }, LookUpConformanceInSignature(sig.getPointer()));
+  return type.subst(
+      [&](SubstitutableType *type) {
+        auto *genericParam = type->getAs<GenericTypeParamType>();
+        if (!genericParam)
+          return Type();
+
+        if (auto *packParam = packParamForElement[{genericParam}])
+          return substitutions(packParam);
+
+        return substitutions(genericParam);
+      },
+      LookUpConformanceInSignature(sig.getPointer()),
+      SubstFlags::PreservePackExpansionLevel);
 }
 
 namespace {

lib/AST/ProtocolConformanceRef.cpp

@@ -109,7 +109,9 @@ ProtocolConformanceRef::subst(Type origType, InFlightSubstitution &IFS) const {
   }
 
   // Check the conformance map.
-  return IFS.lookupConformance(origType->getCanonicalType(), substType, proto);
+  // FIXME: Pack element level?
+  return IFS.lookupConformance(origType->getCanonicalType(), substType, proto,
+                               /*level=*/0);
 }
 
 ProtocolConformanceRef ProtocolConformanceRef::mapConformanceOutOfContext() const {
@@ -120,7 +122,8 @@ ProtocolConformanceRef ProtocolConformanceRef::mapConformanceOutOfContext() cons
             return archetypeType->getInterfaceType();
           return type;
         },
-        MakeAbstractConformanceForGenericType());
+        MakeAbstractConformanceForGenericType(),
+        SubstFlags::PreservePackExpansionLevel);
     return ProtocolConformanceRef(concrete);
   } else if (isPack()) {
     return getPack()->subst(
@@ -129,7 +132,8 @@ ProtocolConformanceRef ProtocolConformanceRef::mapConformanceOutOfContext() cons
             return archetypeType->getInterfaceType();
           return type;
         },
-        MakeAbstractConformanceForGenericType());
+        MakeAbstractConformanceForGenericType(),
+        SubstFlags::PreservePackExpansionLevel);
   }
 
   return *this;

lib/AST/RequirementEnvironment.cpp

@@ -69,7 +69,9 @@ RequirementEnvironment::RequirementEnvironment(
       MakeAbstractConformanceForGenericType();
 
   auto substConcreteType = concreteType.subst(
-      conformanceToWitnessThunkTypeFn, conformanceToWitnessThunkConformanceFn);
+      conformanceToWitnessThunkTypeFn,
+      conformanceToWitnessThunkConformanceFn,
+      SubstFlags::PreservePackExpansionLevel);
 
   // Calculate the depth at which the requirement's generic parameters
   // appear in the witness thunk signature.

lib/AST/SubstitutionMap.cpp

@@ -247,7 +247,8 @@ SubstitutionMap SubstitutionMap::get(GenericSignature genericSig,
     CanType depTy = req.getFirstType()->getCanonicalType();
     auto replacement = depTy.subst(IFS);
     auto *proto = req.getProtocolDecl();
-    auto conformance = IFS.lookupConformance(depTy, replacement, proto);
+    auto conformance = IFS.lookupConformance(depTy, replacement, proto,
+                                             /*level=*/0);
     conformances.push_back(conformance);
   }
 
@@ -440,7 +441,9 @@ SubstitutionMap::lookupConformance(CanType type, ProtocolDecl *proto) const {
 }
 
 SubstitutionMap SubstitutionMap::mapReplacementTypesOutOfContext() const {
-  return subst(MapTypeOutOfContext(), MakeAbstractConformanceForGenericType());
+  return subst(MapTypeOutOfContext(),
+               MakeAbstractConformanceForGenericType(),
+               SubstFlags::PreservePackExpansionLevel);
 }
 
 SubstitutionMap SubstitutionMap::subst(SubstitutionMap subMap,
@@ -829,5 +832,7 @@ SubstitutionMap SubstitutionMap::mapIntoTypeExpansionContext(
   ReplaceOpaqueTypesWithUnderlyingTypes replacer(
       context.getContext(), context.getResilienceExpansion(),
       context.isWholeModuleContext());
-  return this->subst(replacer, replacer, SubstFlags::SubstituteOpaqueArchetypes);
+  return this->subst(replacer, replacer,
+                     SubstFlags::SubstituteOpaqueArchetypes |
+                     SubstFlags::PreservePackExpansionLevel);
 }