PackElementType changes, part 2

include/swift/AST/Types.h

@@ -6414,7 +6414,7 @@ class PackArchetypeType final
       LayoutConstraint Layout);
 
   // Returns the reduced shape type for this pack archetype.
-  CanType getReducedShape() const;
+  CanType getReducedShape();
 
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::PackArchetype;
@@ -7098,16 +7098,6 @@ inline bool TypeBase::isTypeParameter() {
   return t->is<GenericTypeParamType>();
 }
 
-inline bool TypeBase::isParameterPack() {
-  Type t(this);
-
-  while (auto *memberTy = t->getAs<DependentMemberType>())
-    t = memberTy->getBase();
-
-  return t->is<GenericTypeParamType>() &&
-         t->castTo<GenericTypeParamType>()->isParameterPack();
-}
-
 // TODO: This will become redundant once InOutType is removed.
 inline bool TypeBase::isMaterializable() {
   return !(hasLValueType() || is<InOutType>());

include/swift/SIL/SILType.h

@@ -686,12 +686,12 @@ class SILType {
   SILType subst(Lowering::TypeConverter &tc, TypeSubstitutionFn subs,
                 LookupConformanceFn conformances,
                 CanGenericSignature genericSig = CanGenericSignature(),
-                bool shouldSubstituteOpaqueArchetypes = false) const;
+                SubstOptions options = None) const;
 
   SILType subst(SILModule &M, TypeSubstitutionFn subs,
                 LookupConformanceFn conformances,
                 CanGenericSignature genericSig = CanGenericSignature(),
-                bool shouldSubstituteOpaqueArchetypes = false) const;
+                SubstOptions options = None) const;
 
   SILType subst(Lowering::TypeConverter &tc,
                 InFlightSubstitution &IFS,

lib/AST/ParameterPack.cpp

@@ -31,10 +31,18 @@ namespace {
 /// skipping those captured by nested pack expansion types.
 struct PackTypeParameterCollector: TypeWalker {
   llvm::SetVector<Type> typeParams;
+  unsigned expansionLevel;
+  SmallVector<unsigned, 2> elementLevel;
+
+  PackTypeParameterCollector() : expansionLevel(0) {
+    elementLevel.push_back(0);
+  }
 
   Action walkToTypePre(Type t) override {
-    if (t->is<PackExpansionType>())
-      return Action::SkipChildren;
+    if (t->is<PackExpansionType>()) {
+      ++expansionLevel;
+      return Action::Continue;
+    }
 
     if (auto *boundGenericType = dyn_cast<BoundGenericType>(t.getPointer())) {
       if (auto parentType = boundGenericType->getParent())
@@ -58,13 +66,30 @@ struct PackTypeParameterCollector: TypeWalker {
       }
     }
 
-    if (auto *paramTy = t->getAs<GenericTypeParamType>()) {
-      if (paramTy->isParameterPack())
-        typeParams.insert(paramTy);
-    } else if (auto *archetypeTy = t->getAs<PackArchetypeType>()) {
-      typeParams.insert(archetypeTy->getRoot());
+    if (auto *eltType = t->getAs<PackElementType>()) {
+      elementLevel.push_back(eltType->getLevel());
+      return Action::Continue;
     }
 
+    if (elementLevel.back() == expansionLevel) {
+      if (auto *paramTy = t->getAs<GenericTypeParamType>()) {
+        if (paramTy->isParameterPack())
+          typeParams.insert(paramTy);
+      } else if (auto *archetypeTy = t->getAs<PackArchetypeType>()) {
+        typeParams.insert(archetypeTy->getRoot());
+      }
+    }
+
+    return Action::Continue;
+  }
+
+  Action walkToTypePost(Type t) override {
+    if (t->is<PackExpansionType>())
+      --expansionLevel;
+
+    if (t->is<PackElementType>())
+      elementLevel.pop_back();
+
     return Action::Continue;
   }
 };
@@ -90,6 +115,16 @@ bool GenericTypeParamType::isParameterPack() const {
          GenericTypeParamType::TYPE_SEQUENCE_BIT;
 }
 
+bool TypeBase::isParameterPack() {
+  Type t(this);
+
+  while (auto *memberTy = t->getAs<DependentMemberType>())
+    t = memberTy->getBase();
+
+  return t->is<GenericTypeParamType>() &&
+         t->castTo<GenericTypeParamType>()->isParameterPack();
+}
+
 PackType *TypeBase::getPackSubstitutionAsPackType() {
   if (auto pack = getAs<PackType>()) {
     return pack;

lib/AST/SubstitutionMap.cpp

@@ -192,16 +192,13 @@ SubstitutionMap SubstitutionMap::getCanonical(bool canonicalizeSignature) const
 
 SubstitutionMap SubstitutionMap::get(GenericSignature genericSig,
                                      SubstitutionMap substitutions) {
-  if (!genericSig) {
-    assert(!substitutions.hasAnySubstitutableParams() &&
-           "Shouldn't have substitutions here");
+  if (!genericSig)
     return SubstitutionMap();
-  }
 
   return SubstitutionMap::get(genericSig,
            [&](SubstitutableType *type) -> Type {
              return substitutions.lookupSubstitution(
-                      CanSubstitutableType(type));
+                cast<SubstitutableType>(type->getCanonicalType()));
            },
            LookUpConformanceInSubstitutionMap(substitutions));
 }

lib/AST/Type.cpp

@@ -3734,9 +3734,18 @@ PackArchetypeType::get(const ASTContext &Ctx,
       {ShapeType}));
 }
 
-CanType PackArchetypeType::getReducedShape() const {
+CanType PackArchetypeType::getReducedShape() {
+  // mapTypeIntoContext() also calls getReducedShape() via
+  // PackExpansionType::get(), so avoid that by short-circuiting
+  // the case where the pack archetype represents its own
+  // shape class.
   auto shapeType = getTrailingObjects<PackShape>()->shapeType;
-  return getGenericEnvironment()->mapTypeIntoContext(shapeType)->getCanonicalType();
+  if (shapeType->isEqual(getInterfaceType()))
+    return CanType(this);
+
+  return getGenericEnvironment()
+      ->mapTypeIntoContext(shapeType)
+      ->getCanonicalType();
 }
 
 ElementArchetypeType::ElementArchetypeType(

lib/IRGen/MetadataRequest.cpp

@@ -539,7 +539,7 @@ SILType IRGenModule::substOpaqueTypesWithUnderlyingTypes(
         getSILModule().isWholeModule());
     auto underlyingTy =
         type.subst(getSILModule(), replacer, replacer, genericSig,
-                   /*substitute opaque*/ true);
+                   SubstFlags::SubstituteOpaqueArchetypes);
     return underlyingTy;
   }
 

lib/SIL/IR/SILFunctionType.cpp

@@ -4571,13 +4571,15 @@ static bool areABICompatibleParamsOrReturns(SILType a, SILType b,
           inFunction->getModule().isWholeModule());
       if (aa.getASTType()->hasOpaqueArchetype())
         opaqueTypesSubstituted = aa.subst(inFunction->getModule(), replacer,
-                                         replacer, CanGenericSignature(), true);
+                                         replacer, CanGenericSignature(),
+                                         SubstFlags::SubstituteOpaqueArchetypes);
 
       auto opaqueTypesSubstituted2 = bb;
       if (bb.getASTType()->hasOpaqueArchetype())
         opaqueTypesSubstituted2 =
             bb.subst(inFunction->getModule(), replacer, replacer,
-                     CanGenericSignature(), true);
+                     CanGenericSignature(),
+                     SubstFlags::SubstituteOpaqueArchetypes);
       if (opaqueTypesSubstituted == opaqueTypesSubstituted2)
         continue;
     }

lib/SIL/IR/SILTypeSubstitution.cpp

@@ -465,35 +465,29 @@ class SILTypeSubstituter :
 
 } // end anonymous namespace
 
-static bool isSubstitutionInvariant(SILType ty,
-                                    bool shouldSubstituteOpaqueArchetypes) {
+static bool isSubstitutionInvariant(SILType ty, SubstOptions options) {
   return (!ty.hasArchetype() &&
           !ty.hasTypeParameter() &&
-          (!shouldSubstituteOpaqueArchetypes ||
+          (!options.contains(SubstFlags::SubstituteOpaqueArchetypes) ||
            !ty.getRawASTType()->hasOpaqueArchetype()));
 }
 
 SILType SILType::subst(TypeConverter &tc, TypeSubstitutionFn subs,
                        LookupConformanceFn conformances,
                        CanGenericSignature genericSig,
-                       bool shouldSubstituteOpaqueArchetypes) const {
-  if (isSubstitutionInvariant(*this, shouldSubstituteOpaqueArchetypes))
+                       SubstOptions options) const {
+  if (isSubstitutionInvariant(*this, options))
     return *this;
 
-  auto substOptions =
-    (shouldSubstituteOpaqueArchetypes
-       ? SubstOptions(SubstFlags::SubstituteOpaqueArchetypes)
-       : SubstOptions(None));
-  InFlightSubstitution IFS(subs, conformances, substOptions);
-
+  InFlightSubstitution IFS(subs, conformances, options);
   SILTypeSubstituter STST(tc, TypeExpansionContext::minimal(), IFS,
                           genericSig);
   return STST.subst(*this);
 }
 
 SILType SILType::subst(TypeConverter &tc, InFlightSubstitution &IFS,
                        CanGenericSignature genericSig) const {
-  if (isSubstitutionInvariant(*this, IFS.shouldSubstituteOpaqueArchetypes()))
+  if (isSubstitutionInvariant(*this, IFS.getOptions()))
     return *this;
 
   SILTypeSubstituter STST(tc, TypeExpansionContext::minimal(), IFS,
@@ -504,9 +498,8 @@ SILType SILType::subst(TypeConverter &tc, InFlightSubstitution &IFS,
 SILType SILType::subst(SILModule &M, TypeSubstitutionFn subs,
                        LookupConformanceFn conformances,
                        CanGenericSignature genericSig,
-                       bool shouldSubstituteOpaqueArchetypes) const {
-  return subst(M.Types, subs, conformances, genericSig,
-               shouldSubstituteOpaqueArchetypes);
+                       SubstOptions options) const {
+  return subst(M.Types, subs, conformances, genericSig, options);
 }
 
 SILType SILType::subst(TypeConverter &tc, SubstitutionMap subs) const {
@@ -521,7 +514,7 @@ SILType SILType::subst(SILModule &M, SubstitutionMap subs) const{
 
 SILType SILType::subst(SILModule &M, SubstitutionMap subs,
                        TypeExpansionContext context) const {
-  if (isSubstitutionInvariant(*this, false))
+  if (isSubstitutionInvariant(*this, None))
     return *this;
 
   InFlightSubstitutionViaSubMap IFS(subs, None);

lib/SILGen/SILGenConstructor.cpp

@@ -284,17 +284,7 @@ static SubstitutionMap getSubstitutionsForPropertyInitializer(
     // replacement types are the archetypes of the initializer itself.
     return SubstitutionMap::get(
       nominal->getGenericSignatureOfContext(),
-      [&](SubstitutableType *type) -> Type {
-        if (auto gp = type->getAs<GenericTypeParamType>()) {
-          auto archetype = genericEnv->mapTypeIntoContext(gp);
-          if (!gp->isParameterPack())
-            return archetype;
-
-          return PackType::getSingletonPackExpansion(archetype);
-        }
-
-        return Type(type);
-      },
+      QuerySubstitutionMap{genericEnv->getForwardingSubstitutionMap()},
       LookUpConformanceInModule(dc->getParentModule()));
   }
 

lib/SILGen/SILGenProlog.cpp

@@ -910,19 +910,25 @@ static void makeArgument(Type ty, ParamDecl *decl,
                          SmallVectorImpl<SILValue> &args, SILGenFunction &SGF) {
   assert(ty && "no type?!");
 
+  if (ty->is<PackExpansionType>()) {
+    ty = PackType::get(SGF.getASTContext(), {ty});
+  }
+
   // Destructure tuple value arguments.
-  if (TupleType *tupleTy = decl->isInOut() ? nullptr : ty->getAs<TupleType>()) {
-    for (auto fieldType : tupleTy->getElementTypes())
-      makeArgument(fieldType, decl, args, SGF);
-  } else {
-    auto loweredTy = SGF.getLoweredTypeForFunctionArgument(ty);
-    if (decl->isInOut())
-      loweredTy = SILType::getPrimitiveAddressType(loweredTy.getASTType());
-    auto arg = SGF.F.begin()->createFunctionArgument(loweredTy, decl);
-    args.push_back(arg);
+  if (!decl->isInOut()) {
+    if (TupleType *tupleTy = ty->getAs<TupleType>()) {
+      for (auto fieldType : tupleTy->getElementTypes())
+        makeArgument(fieldType, decl, args, SGF);
+      return;
+    }
   }
-}
 
+  auto loweredTy = SGF.getLoweredTypeForFunctionArgument(ty);
+  if (decl->isInOut())
+    loweredTy = SILType::getPrimitiveAddressType(loweredTy.getASTType());
+  auto arg = SGF.F.begin()->createFunctionArgument(loweredTy, decl);
+  args.push_back(arg);
+}
 
 void SILGenFunction::bindParameterForForwarding(ParamDecl *param,
                                      SmallVectorImpl<SILValue> &parameters) {

lib/Sema/TypeCheckGeneric.cpp

@@ -1062,6 +1062,35 @@ CheckGenericArgumentsResult::Kind TypeChecker::checkGenericArguments(
   return CheckGenericArgumentsResult::Success;
 }
 
+CheckGenericArgumentsResult::Kind TypeChecker::checkGenericArguments(
+    ArrayRef<Requirement> requirements) {
+  SmallVector<Requirement, 4> worklist(requirements.begin(), requirements.end());
+
+  bool hadSubstFailure = false;
+
+  while (!worklist.empty()) {
+    auto req = worklist.pop_back_val();
+    switch (req.checkRequirement(worklist, /*allowMissing=*/true)) {
+    case CheckRequirementResult::Success:
+    case CheckRequirementResult::ConditionalConformance:
+    case CheckRequirementResult::PackRequirement:
+      break;
+
+    case CheckRequirementResult::RequirementFailure:
+      return CheckGenericArgumentsResult::RequirementFailure;
+
+    case CheckRequirementResult::SubstitutionFailure:
+      hadSubstFailure = true;
+      break;
+    }
+  }
+
+  if (hadSubstFailure)
+    return CheckGenericArgumentsResult::SubstitutionFailure;
+
+  return CheckGenericArgumentsResult::Success;
+}
+
 Requirement
 RequirementRequest::evaluate(Evaluator &evaluator,
                              WhereClauseOwner owner,

lib/Sema/TypeCheckProtocol.cpp

@@ -5733,9 +5733,7 @@ TypeChecker::conformsToProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
 
   // If we have a conditional requirements that we need to check, do so now.
   if (!condReqs->empty()) {
-    auto conditionalCheckResult = checkGenericArguments(
-        M, *condReqs,
-        [](SubstitutableType *dependentType) { return Type(dependentType); });
+    auto conditionalCheckResult = checkGenericArguments(*condReqs);
     switch (conditionalCheckResult) {
     case CheckGenericArgumentsResult::Success:
       break;

lib/Sema/TypeChecker.h

@@ -535,6 +535,10 @@ checkGenericArguments(ModuleDecl *module, ArrayRef<Requirement> requirements,
                       TypeSubstitutionFn substitutions,
                       SubstOptions options = None);
 
+/// Check the given requirements without applying substitutions.
+CheckGenericArgumentsResult::Kind
+checkGenericArguments(ArrayRef<Requirement> requirements);
+
 /// Checks whether the generic requirements imposed on the nested type
 /// declaration \p decl (if present) are in agreement with the substitutions
 /// that are needed to spell it as a member of the given parent type

lib/Serialization/Serialization.cpp

@@ -5652,6 +5652,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<OptionalTypeLayout>();
   registerDeclTypeAbbr<DynamicSelfTypeLayout>();
   registerDeclTypeAbbr<PackExpansionTypeLayout>();
+  registerDeclTypeAbbr<PackElementTypeLayout>();
   registerDeclTypeAbbr<PackTypeLayout>();
   registerDeclTypeAbbr<SILPackTypeLayout>();
 

test/SILGen/variadic_generic_allocating_init.swift

@@ -0,0 +1,17 @@
+// RUN: %target-swift-emit-silgen %s -disable-availability-checking | %FileCheck %s
+
+class C<each T> {
+  var values: (repeat each T)
+
+  // CHECK-LABEL: sil hidden [exact_self_class] [ossa] @$s32variadic_generic_allocating_init1CC9fromTupleACyxxQp_QPGxxQp_t_tcfC : $@convention(method) <each T> (@pack_owned Pack{repeat each T}, @thick C<repeat each T>.Type) -> @owned C<repeat each T> {
+  // CHECK: bb0(%0 : $*Pack{repeat each T}, %1 : $@thick C<repeat each T>.Type):
+  init(fromTuple: (repeat each T)) {
+    self.values = fromTuple
+  }
+
+  // CHECK-LABEL: sil hidden [exact_self_class] [ossa] @$s32variadic_generic_allocating_init1CC8fromPackACyxxQp_QPGxxQp_tcfC : $@convention(method) <each T> (@pack_owned Pack{repeat each T}, @thick C<repeat each T>.Type) -> @owned C<repeat each T> {
+  // CHECK: bb0(%0 : $*Pack{repeat each T}, %1 : $@thick C<repeat each T>.Type):
+  init(fromPack: repeat each T) {
+    self.values = (repeat each fromPack)
+  }
+}