Merge pull request #64684 from slavapestov/variadic-generics-cherry-picks-5.9

[5.9] Variadic generics cherry-picks

Author: slavapestov

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -122,10 +122,26 @@ public enum ArgumentConvention {
   /// guarantees its validity for the entirety of the call.
   case directGuaranteed
 
+  /// This argument is a value pack of mutable references to storage,
+  /// which the function is being given exclusive access to.  The elements
+  /// must be passed indirectly.
+  case packInout
+
+  /// This argument is a value pack, and ownership of the elements is being
+  /// transferred into this function.  Whether the elements are passed
+  /// indirectly is recorded in the pack type.
+  case packOwned
+
+  /// This argument is a value pack, and ownership of the elements is not
+  /// being transferred into this function.  Whether the elements are passed
+  /// indirectly is recorded in the pack type.
+  case packGuaranteed
+
   public var isIndirect: Bool {
     switch self {
     case .indirectIn, .indirectInGuaranteed,
-         .indirectInout, .indirectInoutAliasable, .indirectOut:
+         .indirectInout, .indirectInoutAliasable, .indirectOut,
+         .packInout, .packOwned, .packGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed:
       return false
@@ -134,20 +150,23 @@ public enum ArgumentConvention {
 
   public var isIndirectIn: Bool {
     switch self {
-    case .indirectIn, .indirectInGuaranteed:
+    case .indirectIn, .indirectInGuaranteed,
+         .packOwned, .packGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed,
-         .indirectInout, .indirectInoutAliasable, .indirectOut:
+         .indirectInout, .indirectInoutAliasable, .indirectOut,
+         .packInout:
       return false
     }
   }
 
   public var isGuaranteed: Bool {
     switch self {
-    case .indirectInGuaranteed, .directGuaranteed:
+    case .indirectInGuaranteed, .directGuaranteed, .packGuaranteed:
       return true
     case .indirectIn, .directOwned, .directUnowned,
-         .indirectInout, .indirectInoutAliasable, .indirectOut:
+         .indirectInout, .indirectInoutAliasable, .indirectOut,
+         .packInout, .packOwned:
       return false
     }
   }
@@ -157,7 +176,10 @@ public enum ArgumentConvention {
     case .indirectIn,
          .indirectOut,
          .indirectInGuaranteed,
-         .indirectInout:
+         .indirectInout,
+         .packInout,
+         .packOwned,
+         .packGuaranteed:
       return true
 
     case .indirectInoutAliasable,
@@ -171,15 +193,18 @@ public enum ArgumentConvention {
   public var isInout: Bool {
     switch self {
     case .indirectInout,
-         .indirectInoutAliasable:
+         .indirectInoutAliasable,
+         .packInout:
       return true
 
     case .indirectIn,
          .indirectOut,
          .indirectInGuaranteed,
          .directUnowned,
          .directGuaranteed,
-         .directOwned:
+         .directOwned,
+         .packOwned,
+         .packGuaranteed:
       return false
     }
   }
@@ -204,6 +229,9 @@ extension BridgedArgumentConvention {
       case .Direct_Owned:            return .directOwned
       case .Direct_Unowned:          return .directUnowned
       case .Direct_Guaranteed:       return .directGuaranteed
+      case .Pack_Inout:              return .packInout
+      case .Pack_Owned:              return .packOwned
+      case .Pack_Guaranteed:         return .packGuaranteed
       default:
         fatalError("unsupported argument convention")
     }

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -541,12 +541,12 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
         result.ownership = SideEffects.Ownership()
       }
       switch convention {
-      case .indirectIn:
+      case .indirectIn, .packOwned:
         result.memory.write = false
-      case .indirectInGuaranteed:
+      case .indirectInGuaranteed, .packGuaranteed:
         result.memory.write = false
         result.ownership.destroy = false
-      case .indirectOut:
+      case .indirectOut, .packInout:
         result.memory.read = false
         result.ownership.copy = false
         result.ownership.destroy = false

include/swift/AST/Types.h

@@ -71,6 +71,7 @@ class Identifier;
 class InOutType;
 class OpaqueTypeDecl;
 class OpenedArchetypeType;
+class PackExpansionType;
 class PackType;
 enum class ParamSpecifier : uint8_t;
 class PlaceholderTypeRepr;
@@ -2414,6 +2415,12 @@ class TupleType final : public TypeBase, public llvm::FoldingSetNode,
 
   unsigned getNumElements() const { return Bits.TupleType.Count; }
 
+  /// Returns the number of non-PackExpansionType elements. This is the
+  /// minimum length of the tuple after substitution; a tuple with
+  /// zero or one scalar elements is unwrapped if it would otherwise be
+  /// a one-element tuple after substitution.
+  unsigned getNumScalarElements() const;
+
   /// getElements - Return the elements of this tuple.
   ArrayRef<TupleTypeElt> getElements() const {
     return {getTrailingObjects<TupleTypeElt>(), getNumElements()};
@@ -6838,6 +6845,8 @@ class PackType final : public TypeBase, public llvm::FoldingSetNode,
 
   bool containsPackExpansionType() const;
 
+  PackExpansionType *unwrapSingletonPackExpansion() const;
+
   CanTypeWrapper<PackType> getReducedShape();
 
 public:
@@ -6876,6 +6885,8 @@ BEGIN_CAN_TYPE_WRAPPER(PackType, Type)
   CanTypeArrayRef getElementTypes() const {
     return CanTypeArrayRef(getPointer()->getElementTypes());
   }
+
+  CanTypeWrapper<PackExpansionType> unwrapSingletonPackExpansion() const;
 END_CAN_TYPE_WRAPPER(PackType, Type)
 
 inline CanPackType CanTupleType::getInducedPackType() const {
@@ -6964,6 +6975,13 @@ BEGIN_CAN_TYPE_WRAPPER(PackExpansionType, Type)
   }
 END_CAN_TYPE_WRAPPER(PackExpansionType, Type)
 
+
+inline CanTypeWrapper<PackExpansionType>
+CanPackType::unwrapSingletonPackExpansion() const {
+  return CanPackExpansionType(
+      getPointer()->unwrapSingletonPackExpansion());
+}
+
 /// getASTContext - Return the ASTContext that this type belongs to.
 inline ASTContext &TypeBase::getASTContext() const {
   // If this type is canonical, it has the ASTContext in it.

include/swift/IRGen/GenericRequirement.h

@@ -76,7 +76,6 @@ class GenericRequirement {
   }
 
   static GenericRequirement forShape(CanType type) {
-    assert(!isa<PackType>(type));
     assert(type->isParameterPack() || isa<PackArchetypeType>(type));
     return GenericRequirement(Kind::Shape, type, nullptr);
   }
@@ -92,7 +91,6 @@ class GenericRequirement {
   }
 
   static GenericRequirement forMetadata(CanType type) {
-    assert(!isa<PackType>(type));
     auto kind = ((type->isParameterPack() ||
                   isa<PackArchetypeType>(type))
                  ? Kind::MetadataPack : Kind::Metadata);
@@ -110,7 +108,6 @@ class GenericRequirement {
   }
 
   static GenericRequirement forWitnessTable(CanType type, ProtocolDecl *proto) {
-    assert(!isa<PackType>(type));
     auto kind = ((type->isParameterPack() ||
                   isa<PackArchetypeType>(type))
                  ? Kind::WitnessTablePack

include/swift/Runtime/RuntimeFunctions.def

@@ -1008,6 +1008,28 @@ FUNCTION(CompareProtocolConformanceDescriptors,
          ATTRS(NoUnwind, ReadNone, WillReturn),
          EFFECT(NoEffect)) // ?
 
+// SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+// const Metadata * const *
+// swift_allocateMetadataPack(const Metadata * const *ptr, size_t count);
+FUNCTION(AllocateMetadataPack,
+         swift_allocateMetadataPack, SwiftCC,
+         AlwaysAvailable,  // FIXME
+         RETURNS(TypeMetadataPtrPtrTy),
+         ARGS(TypeMetadataPtrPtrTy, SizeTy),
+         ATTRS(NoUnwind, WillReturn),
+         EFFECT(MetaData)) // ?
+
+// SWIFT_RUNTIME_EXPORT SWIFT_CC(swift)
+// const WitnessTable * const *
+// swift_allocateWitnessTablePack(const WitnessTable * const *ptr, size_t count);
+FUNCTION(AllocateWitnessTablePack,
+         swift_allocateWitnessTablePack, SwiftCC,
+         AlwaysAvailable,  // FIXME
+         RETURNS(WitnessTablePtrPtrTy),
+         ARGS(WitnessTablePtrPtrTy, SizeTy),
+         ATTRS(NoUnwind, WillReturn),
+         EFFECT(MetaData)) // ?
+
 // Metadata *swift_getMetatypeMetadata(Metadata *instanceTy);
 FUNCTION(GetMetatypeMetadata, swift_getMetatypeMetadata, C_CC, AlwaysAvailable,
          RETURNS(TypeMetadataPtrTy),

include/swift/SIL/SILCloner.h

@@ -279,34 +279,22 @@ class SILCloner : protected SILInstructionVisitor<ImplClass> {
     if (type->getNumElements() == 0) return false;
 
     // Do a first pass over the tuple elements to check out the
-    // non-expansions.  If there's more than one of them, or any of them
-    // is labeled, we definitely stay a tuple and don't need to substitute
-    // any of the expansions.
-    unsigned numScalarElements = 0;
-    for (auto index : indices(type->getElements())) {
-      auto eltType = type.getElementType(index);
-      // Ignore pack expansions in this pass.
-      if (isa<PackExpansionType>(eltType)) continue;
-
-      // If there's a labeled scalar element, we'll stay a tuple.
-      if (type->getElement(index).hasName()) return false;
-
-      // If there are multiple scalar elements, we'll stay a tuple.
-      if (++numScalarElements > 1) return false;
-    }
-
-    assert(numScalarElements <= 1);
-
-    // We must have expansions if we got here: if all the elements were
-    // scalar, and none of them were labelled, and there wasn't more than
-    // one of them, and there was at least one of them, then somehow
-    // we had a tuple with a single unlabeled element.
+    // non-expansions.  If there's more than one of them we definitely
+    // stay a tuple and don't need to substitute any of the expansions.
+    unsigned numScalarElements = type->getNumScalarElements();
+    if (numScalarElements > 1)
+      return false;
 
     // Okay, we need to substitute the count types for the expansions.
     for (auto index : indices(type->getElements())) {
       // Ignore non-expansions because we've already counted them.
       auto expansion = dyn_cast<PackExpansionType>(type.getElementType(index));
-      if (!expansion) continue;
+      if (!expansion) {
+        // If we have a non-expansion with a label, we stay a tuple.
+        if (type->getElement(index).hasName())
+          return false;
+        continue;
+      }
 
       // Substitute the shape class of the expansion.
       auto newShapeClass = getOpASTType(expansion.getCountType());

lib/AST/ASTContext.cpp

@@ -3781,6 +3781,9 @@ ParameterizedProtocolType *ParameterizedProtocolType::get(const ASTContext &C,
 
   auto size = totalSizeToAlloc<Type>(args.size());
   auto mem = C.Allocate(size, alignof(ParameterizedProtocolType), arena);
+
+  properties |= RecursiveTypeProperties::HasParameterizedExistential;
+
   auto paramTy = new (mem) ParameterizedProtocolType(
         isCanonical ? &C : nullptr, baseTy, args, properties);
   C.getImpl().getArena(arena).ParameterizedProtocolTypes.InsertNode(
@@ -3871,8 +3874,6 @@ ExistentialMetatypeType::get(Type T, Optional<MetatypeRepresentation> repr,
     T = existential->getConstraintType();
 
   auto properties = T->getRecursiveProperties();
-  if (T->is<ParameterizedProtocolType>())
-    properties |= RecursiveTypeProperties::HasParameterizedExistential;
   auto arena = getArena(properties);
 
   unsigned reprKey;
@@ -4742,8 +4743,6 @@ Type ExistentialType::get(Type constraint) {
     printWithAny = false;
 
   auto properties = constraint->getRecursiveProperties();
-  if (constraint->is<ParameterizedProtocolType>())
-    properties |= RecursiveTypeProperties::HasParameterizedExistential;
   auto arena = getArena(properties);
 
   auto &entry = C.getImpl().getArena(arena).ExistentialTypes[constraint];

lib/AST/ASTDemangler.cpp

@@ -674,8 +674,7 @@ Type ASTBuilder::createConstrainedExistentialType(
 
     case RequirementKind::SameType:
       if (auto *DMT = req.getFirstType()->getAs<DependentMemberType>())
-        if (baseDecl->getAssociatedType(DMT->getName()))
-          cmap[DMT->getName()] = req.getSecondType();
+        cmap[DMT->getName()] = req.getSecondType();
     }
   }
   llvm::SmallVector<Type, 4> args;

lib/AST/ASTMangler.cpp

@@ -1411,14 +1411,18 @@ void ASTMangler::appendType(Type type, GenericSignature sig,
     }
 
     case TypeKind::ProtocolComposition: {
+      auto *PCT = cast<ProtocolCompositionType>(tybase);
+      if (PCT->hasParameterizedExistential())
+        return appendConstrainedExistential(PCT, sig, forDecl);
+
       // We mangle ProtocolType and ProtocolCompositionType using the
       // same production:
-      auto layout = type->getExistentialLayout();
+      auto layout = PCT->getExistentialLayout();
       return appendExistentialLayout(layout, sig, forDecl);
     }
 
     case TypeKind::ParameterizedProtocol:
-      llvm_unreachable("Handled by generalized existential mangling!");
+      return appendConstrainedExistential(tybase, sig, forDecl);
 
     case TypeKind::Existential: {
       auto *ET = cast<ExistentialType>(tybase);

lib/AST/ParameterPack.cpp

@@ -102,6 +102,16 @@ CanType PackExpansionType::getReducedShape() {
   return CanType(PackExpansionType::get(reducedShape, reducedShape));
 }
 
+unsigned TupleType::getNumScalarElements() const {
+  unsigned n = 0;
+  for (auto elt : getElements()) {
+    if (!elt.getType()->is<PackExpansionType>())
+      ++n;
+  }
+
+  return n;
+}
+
 bool TupleType::containsPackExpansionType() const {
   for (auto elt : getElements()) {
     if (elt.getType()->is<PackExpansionType>())
@@ -290,6 +300,18 @@ CanPackType CanPackType::getSingletonPackExpansion(CanType param) {
   return CanPackType(PackType::getSingletonPackExpansion(param));
 }
 
+PackExpansionType *PackType::unwrapSingletonPackExpansion() const {
+  if (getNumElements() == 1) {
+    if (auto expansion = getElementTypes()[0]->getAs<PackExpansionType>()) {
+      auto pattern = expansion->getPatternType();
+      if (pattern->isParameterPack() || pattern->is<PackArchetypeType>())
+        return expansion;
+    }
+  }
+
+  return nullptr;
+}
+
 bool SILPackType::containsPackExpansionType() const {
   for (auto type : getElementTypes()) {
     if (isa<PackExpansionType>(type))

lib/Demangling/NodePrinter.cpp

@@ -310,7 +310,6 @@ class NodePrinter {
     case Node::Kind::Pack:
     case Node::Kind::SILPackDirect:
     case Node::Kind::SILPackIndirect:
-    case Node::Kind::ConstrainedExistential:
     case Node::Kind::ConstrainedExistentialRequirementList:
     case Node::Kind::ConstrainedExistentialSelf:
     case Node::Kind::Protocol:
@@ -340,6 +339,7 @@ class NodePrinter {
     case Node::Kind::ProtocolListWithAnyObject:
       return Node->getChild(0)->getChild(0)->getNumChildren() == 0;
 
+    case Node::Kind::ConstrainedExistential:
     case Node::Kind::PackExpansion:
     case Node::Kind::ProtocolListWithClass:
     case Node::Kind::AccessorAttachedMacroExpansion: