Merge pull request #64777 from slavapestov/sil-optimizer-variadic-generics

SIL optimizer fixes for variadic generics

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/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/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/IRGen/Fulfillment.cpp

@@ -182,14 +182,12 @@ bool FulfillmentMap::searchTypeMetadata(IRGenModule &IGM, CanType type,
 static CanType getSingletonPackExpansionParameter(CanPackType packType,
                     const FulfillmentMap::InterestingKeysCallback &keys,
                     Optional<unsigned> &packExpansionComponent) {
-  if (packType->getNumElements() != 1)
-    return CanType();
-  auto expansion = dyn_cast<PackExpansionType>(packType.getElementType(0));
-  if (!expansion || !keys.isInterestingPackExpansion(expansion))
-    return CanType();
-
-  packExpansionComponent = 0;
-  return expansion.getPatternType();
+  if (auto expansion = packType.unwrapSingletonPackExpansion()) {
+    if (keys.isInterestingPackExpansion(expansion)) {
+      packExpansionComponent = 0;
+      return expansion.getPatternType();
+    }
+  }
 }
 
 bool FulfillmentMap::searchTypeMetadataPack(IRGenModule &IGM,
@@ -405,10 +403,7 @@ bool FulfillmentMap::searchShapeRequirement(IRGenModule &IGM, CanType argType,
   // there aren't expansions over pack parameters with different shapes,
   // we should always be able to turn this into the equation
   // `ax + b = <fulfilled count>` and then solve that.
-  if (packType->getNumElements() != 1)
-    return false;
-  auto expansion =
-    dyn_cast<PackExpansionType>(packType.getElementType(0));
+  auto expansion = packType.unwrapSingletonPackExpansion();
   if (!expansion)
     return false;