Merge pull request #68701 from slavapestov/parameter-pack-fixes-5.10

[5.10] Various bug fixes

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -59,10 +59,14 @@ class ASTBuilder {
   /// Created lazily.
   DeclContext *NotionalDC = nullptr;
 
-  /// The generic signature for interpreting type parameters. This is used
-  /// because the mangling for a type parameter doesn't record whether it
-  /// is a pack or not, so we have to find it here.
-  GenericSignature GenericSig;
+  /// The depth and index of each parameter pack in the current generic
+  /// signature. We need this because the mangling for a type parameter
+  /// doesn't record whether it is a pack or not; we find the correct
+  /// depth and index in this array, and use its pack-ness.
+  llvm::SmallVector<std::pair<unsigned, unsigned>, 2> ParameterPacks;
+
+  /// For saving and restoring generic parameters.
+  llvm::SmallVector<decltype(ParameterPacks), 2> ParameterPackStack;
 
   /// This builder doesn't perform "on the fly" substitutions, so we preserve
   /// all pack expansions. We still need an active expansion stack though,
@@ -71,7 +75,7 @@ class ASTBuilder {
   /// - advancePackExpansion()
   /// - createExpandedPackElement()
   /// - endPackExpansion()
-  llvm::SmallVector<Type> ActivePackExpansions;
+  llvm::SmallVector<Type, 2> ActivePackExpansions;
 
 public:
   using BuiltType = swift::Type;
@@ -84,7 +88,12 @@ class ASTBuilder {
   static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
 
   explicit ASTBuilder(ASTContext &ctx, GenericSignature genericSig)
-    : Ctx(ctx), GenericSig(genericSig) {}
+    : Ctx(ctx) {
+    for (auto *paramTy : genericSig.getGenericParams()) {
+      if (paramTy->isParameterPack())
+        ParameterPacks.emplace_back(paramTy->getDepth(), paramTy->getIndex());
+    }
+  }
 
   ASTContext &getASTContext() { return Ctx; }
   DeclContext *getNotionalDC();
@@ -165,6 +174,9 @@ class ASTBuilder {
       Type instance,
       llvm::Optional<Demangle::ImplMetatypeRepresentation> repr = llvm::None);
 
+  void pushGenericParams(ArrayRef<std::pair<unsigned, unsigned>> parameterPacks);
+  void popGenericParams();
+
   Type createGenericTypeParameterType(unsigned depth, unsigned index);
 
   Type createDependentMemberType(StringRef member, Type base);

include/swift/Demangling/TypeDecoder.h

@@ -376,7 +376,8 @@ void decodeRequirement(NodePointer node,
                        llvm::SmallVectorImpl<BuiltRequirement> &requirements,
                        BuilderType &Builder) {
   for (auto &child : *node) {
-    if (child->getKind() == Demangle::Node::Kind::DependentGenericParamCount)
+    if (child->getKind() == Demangle::Node::Kind::DependentGenericParamCount ||
+        child->getKind() == Demangle::Node::Kind::DependentGenericParamPackMarker)
       continue;
 
     if (child->getNumChildren() != 2)
@@ -1180,28 +1181,12 @@ class TypeDecoder {
       llvm::SmallVector<Field, 4> fields;
       llvm::SmallVector<BuiltSubstitution, 4> substitutions;
       llvm::SmallVector<BuiltRequirement, 4> requirements;
+      llvm::SmallVector<BuiltType, 4> genericParams;
 
       if (Node->getNumChildren() < 1)
         return MAKE_NODE_TYPE_ERROR0(Node, "no children");
 
-      auto fieldsNode = Node->getChild(0);
-      if (fieldsNode->getKind() != NodeKind::SILBoxLayout)
-        return MAKE_NODE_TYPE_ERROR0(fieldsNode, "expected layout");
-      for (auto *fieldNode : *fieldsNode) {
-        bool isMutable;
-        switch (fieldNode->getKind()) {
-        case NodeKind::SILBoxMutableField: isMutable = true; break;
-        case NodeKind::SILBoxImmutableField: isMutable = false; break;
-        default:
-          return MAKE_NODE_TYPE_ERROR0(fieldNode, "unhandled field type");
-        }
-        if (fieldNode->getNumChildren() < 1)
-          return MAKE_NODE_TYPE_ERROR0(fieldNode, "no children");
-        auto type = decodeMangledType(fieldNode->getChild(0), depth + 1);
-        if (type.isError())
-          return type;
-        fields.emplace_back(type.getType(), isMutable);
-      }
+      bool pushedGenericParams = false;
 
       if (Node->getNumChildren() > 1) {
         auto *substNode = Node->getChild(2);
@@ -1218,47 +1203,76 @@ class TypeDecoder {
               dependentGenericSignatureNode,
               "fewer children (%zu) than required (1)",
               dependentGenericSignatureNode->getNumChildren());
-        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                          BuilderType>(dependentGenericSignatureNode,
-                                       requirements,
-                                       Builder /*,
-[&](NodePointer Node) -> BuiltType {
-return decodeMangledType(Node, depth + 1).getType();
-},
-[&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
-return {}; // Not implemented!
-},
-[&](LayoutConstraintKind Kind, unsigned SizeInBits,
-unsigned Alignment) -> BuiltLayoutConstraint {
-return {}; // Not Implemented!
-}*/);
+
         // The number of generic parameters at each depth are in a mini
         // state machine and come first.
         llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
         for (auto *reqNode : *dependentGenericSignatureNode)
           if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
             if (reqNode->hasIndex())
               genericParamsAtDepth.push_back(reqNode->getIndex());
-        unsigned paramDepth = 0;
-        unsigned index = 0;
-        for (auto *subst : *substNode) {
-          if (paramDepth >= genericParamsAtDepth.size())
-            return MAKE_NODE_TYPE_ERROR0(
-                dependentGenericSignatureNode,
-                "more substitutions than generic params");
-          while (index >= genericParamsAtDepth[paramDepth])
-            ++paramDepth, index = 0;
+
+        llvm::SmallVector<std::pair<unsigned, unsigned>> parameterPacks;
+        for (auto &child : *dependentGenericSignatureNode) {
+          if (child->getKind() == Demangle::Node::Kind::DependentGenericParamPackMarker) {
+            auto *marker = child->getChild(0)->getChild(0);
+            parameterPacks.emplace_back(marker->getChild(0)->getIndex(),
+                                        marker->getChild(1)->getIndex());
+          }
+        }
+
+        Builder.pushGenericParams(parameterPacks);
+        pushedGenericParams = true;
+
+        // Decode generic parameter types.
+        for (unsigned d = 0; d < genericParamsAtDepth.size(); ++d) {
+          for (unsigned i = 0; i < genericParamsAtDepth[d]; ++i) {
+            auto paramTy = Builder.createGenericTypeParameterType(d, i);
+            genericParams.push_back(paramTy);
+          }
+        }
+
+        // Decode requirements.
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                          BuilderType>(dependentGenericSignatureNode,
+                                       requirements,
+                                       Builder);
+
+        // Decode substitutions.
+        for (unsigned i = 0, e = substNode->getNumChildren(); i < e; ++i) {
+          auto *subst = substNode->getChild(i);
           auto substTy = decodeMangledType(subst, depth + 1,
                                            /*forRequirement=*/false);
           if (substTy.isError())
             return substTy;
-          auto paramTy = Builder.createGenericTypeParameterType(
-              paramDepth, index);
-          substitutions.emplace_back(paramTy, substTy.getType());
-          ++index;
+          substitutions.emplace_back(genericParams[i], substTy.getType());
         }
       }
 
+      // Decode field types.
+      auto fieldsNode = Node->getChild(0);
+      if (fieldsNode->getKind() != NodeKind::SILBoxLayout)
+        return MAKE_NODE_TYPE_ERROR0(fieldsNode, "expected layout");
+      for (auto *fieldNode : *fieldsNode) {
+        bool isMutable;
+        switch (fieldNode->getKind()) {
+        case NodeKind::SILBoxMutableField: isMutable = true; break;
+        case NodeKind::SILBoxImmutableField: isMutable = false; break;
+        default:
+          return MAKE_NODE_TYPE_ERROR0(fieldNode, "unhandled field type");
+        }
+        if (fieldNode->getNumChildren() < 1)
+          return MAKE_NODE_TYPE_ERROR0(fieldNode, "no children");
+        auto type = decodeMangledType(fieldNode->getChild(0), depth + 1);
+        if (type.isError())
+          return type;
+        fields.emplace_back(type.getType(), isMutable);
+      }
+
+      if (pushedGenericParams) {
+        Builder.popGenericParams();
+      }
+
       return Builder.createSILBoxTypeWithLayout(fields, substitutions,
                                                 requirements);
     }

include/swift/RemoteInspection/TypeRefBuilder.h

@@ -910,8 +910,12 @@ class TypeRefBuilder {
     return MetatypeTypeRef::create(*this, instance, WasAbstract);
   }
 
+  void pushGenericParams(llvm::ArrayRef<std::pair<unsigned, unsigned>> parameterPacks) {}
+  void popGenericParams() {}
+
   const GenericTypeParameterTypeRef *
   createGenericTypeParameterType(unsigned depth, unsigned index) {
+    // FIXME: variadic generics
     return GenericTypeParameterTypeRef::create(*this, depth, index);
   }
 

lib/AST/ASTDemangler.cpp

@@ -31,6 +31,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Types.h"
+#include "swift/Basic/Defer.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 #include "llvm/ADT/StringSwitch.h"
@@ -731,23 +732,28 @@ Type ASTBuilder::createMetatypeType(
   return MetatypeType::get(instance, getMetatypeRepresentation(*repr));
 }
 
+void ASTBuilder::pushGenericParams(ArrayRef<std::pair<unsigned, unsigned>> parameterPacks) {
+  ParameterPackStack.push_back(ParameterPacks);
+  ParameterPacks.clear();
+  ParameterPacks.append(parameterPacks.begin(), parameterPacks.end());
+}
+
+void ASTBuilder::popGenericParams() {
+  ParameterPacks = ParameterPackStack.back();
+  ParameterPackStack.pop_back();
+}
+
 Type ASTBuilder::createGenericTypeParameterType(unsigned depth,
                                                 unsigned index) {
-  // If we have a generic signature, find the parameter with the matching
-  // depth and index and return it, to get the correct value for the
-  // isParameterPack() bit.
-  if (GenericSig) {
-    for (auto paramTy : GenericSig.getGenericParams()) {
-      if (paramTy->getDepth() == depth && paramTy->getIndex() == index) {
-        return paramTy;
+  if (!ParameterPacks.empty()) {
+    for (auto pair : ParameterPacks) {
+      if (pair.first == depth && pair.second == index) {
+        return GenericTypeParamType::get(/*isParameterPack*/ true,
+                                         depth, index, Ctx);
       }
     }
-
-    return Type();
   }
 
-  // Otherwise, just assume we're not working with variadic generics.
-  // FIXME: Should we always require a generic signature in this case?
   return GenericTypeParamType::get(/*isParameterPack*/ false,
                                    depth, index, Ctx);
 }
@@ -1039,15 +1045,25 @@ LayoutConstraint ASTBuilder::getLayoutConstraintWithSizeAlign(
 CanGenericSignature ASTBuilder::demangleGenericSignature(
     NominalTypeDecl *nominalDecl,
     NodePointer node) {
-  llvm::SaveAndRestore<GenericSignature> savedSignature(
-      GenericSig, nominalDecl->getGenericSignature());
+  auto baseGenericSig = nominalDecl->getGenericSignature();
+
+  // The generic signature is for a constrained extension of nominalDecl, so
+  // we introduce the parameter packs from the nominal's generic signature.
+  ParameterPackStack.push_back(ParameterPacks);
+  ParameterPacks.clear();
+  for (auto *paramTy : baseGenericSig.getGenericParams()) {
+    if (paramTy->isParameterPack())
+      ParameterPacks.emplace_back(paramTy->getDepth(), paramTy->getIndex());
+  }
+  SWIFT_DEFER { popGenericParams(); };
 
+  // Constrained extensions mangle the subset of requirements not satisfied
+  // by the nominal's generic signature.
   SmallVector<Requirement, 2> requirements;
-
   decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
                     ASTBuilder>(node, requirements, *this);
-  return buildGenericSignature(Ctx, nominalDecl->getGenericSignature(),
-                               {}, std::move(requirements))
+
+  return buildGenericSignature(Ctx, baseGenericSig, {}, std::move(requirements))
       .getCanonicalSignature();
 }
 

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -559,6 +559,7 @@ RewriteContext::getRelativeSubstitutionSchemaFromType(
     ArrayRef<Term> substitutions,
     SmallVectorImpl<Term> &result) {
   assert(!concreteType->isTypeParameter() && "Must have a concrete type here");
+  assert(!concreteType->is<PackExpansionType>());
 
   if (!concreteType->hasTypeParameter())
     return concreteType;
@@ -604,6 +605,7 @@ RewriteContext::getSubstitutionSchemaFromType(CanType concreteType,
                                               const ProtocolDecl *proto,
                                               SmallVectorImpl<Term> &result) {
   assert(!concreteType->isTypeParameter() && "Must have a concrete type here");
+  assert(!concreteType->is<PackExpansionType>());
 
   if (!concreteType->hasTypeParameter())
     return concreteType;

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -620,7 +620,8 @@ AbstractGenericSignatureRequest::evaluate(
             return Type(type);
           },
           MakeAbstractConformanceForGenericType(),
-          SubstFlags::AllowLoweredTypes);
+          SubstFlags::AllowLoweredTypes |
+          SubstFlags::PreservePackExpansionLevel);
       resugaredRequirements.push_back(resugaredReq);
     }
 

lib/SILGen/SILGenApply.cpp

@@ -7023,11 +7023,10 @@ ManagedValue SILGenFunction::emitReadAsyncLetBinding(SILLocation loc,
   assert(visitor.varAddr && "didn't find var in pattern?");
 
   // Load and reabstract the value if needed.
-  auto genericSig = F.getLoweredFunctionType()->getInvocationGenericSignature();
   auto substVarTy = var->getTypeInContext()->getCanonicalType();
-  auto substAbstraction = AbstractionPattern(genericSig, substVarTy);
-  return emitLoad(loc, visitor.varAddr, substAbstraction, substVarTy,
-                  getTypeLowering(substAbstraction, substVarTy),
+  return emitLoad(loc, visitor.varAddr,
+                  AbstractionPattern::getOpaque(), substVarTy,
+                  getTypeLowering(substVarTy),
                   SGFContext(), IsNotTake);
 }
 

lib/SILOptimizer/UtilityPasses/SerializeSILPass.cpp

@@ -57,11 +57,11 @@ class MapOpaqueArchetypes : public SILCloner<MapOpaqueArchetypes> {
              .getTypeExpansionContext()
              .shouldLookThroughOpaqueTypeArchetypes())
       return ty;
-    // Remap types containing opaque result types in the current context.
-    return getBuilder()
-        .getTypeLowering(SILType::getPrimitiveObjectType(ty))
-        .getLoweredType()
-        .getASTType();
+
+    return substOpaqueTypesWithUnderlyingTypes(
+        ty,
+        TypeExpansionContext(getBuilder().getFunction()),
+        /*allowLoweredTypes=*/false);
   }
 
   ProtocolConformanceRef remapConformance(Type ty,

lib/Sema/TypeCheckType.cpp

@@ -806,7 +806,7 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
     if (options.is(TypeResolverContext::ExistentialConstraint))
       options |= TypeResolutionFlags::DisallowOpaqueTypes;
     auto argOptions = options.withoutContext().withContext(
-        TypeResolverContext::GenericArgument);
+        TypeResolverContext::ProtocolGenericArgument);
     auto genericResolution = resolution.withOptions(argOptions);
 
     SmallVector<Type, 2> argTys;

stdlib/public/runtime/MetadataLookup.cpp

@@ -1869,6 +1869,9 @@ class DecodedMetadataBuilder {
     return BuiltType();
   }
 
+  void pushGenericParams(llvm::ArrayRef<std::pair<unsigned, unsigned>> parameterPacks) {}
+  void popGenericParams() {}
+
   BuiltType
   createGenericTypeParameterType(unsigned depth, unsigned index) const {
     // Use the callback, when provided.