IRGen: Fulfill pack metadata from tuple metadata

When the SelfMetadata in a witness thunk is the tuple type (repeat each Self),
we can fulfill the pack shape and type metadata for Pack{repeat each Self}
from tuple metadata.

The length is trivially projected; the type metadata pack is slightly more
involved, because tuple metadata stores a list of element/offset pairs, so
we must stack allocate a pack and fill it in.

Author: slavapestov

lib/IRGen/Fulfillment.cpp

@@ -173,7 +173,33 @@ bool FulfillmentMap::searchTypeMetadata(IRGenModule &IGM, CanType type,
                                      source, std::move(path), keys);
   }
 
-  // TODO: tuples
+  if (auto tupleType = dyn_cast<TupleType>(type)) {
+    if (tupleType->getNumElements() == 1 &&
+        isa<PackExpansionType>(tupleType.getElementType(0))) {
+
+      bool hadFulfillment = false;
+      auto packType = tupleType.getInducedPackType();
+
+      {
+        auto argPath = path;
+        argPath.addTuplePackComponent();
+        hadFulfillment |= searchTypeMetadataPack(IGM, packType,
+                                                 isExact, metadataState, source,
+                                                 std::move(argPath), keys);
+      }
+
+      {
+        auto argPath = path;
+        argPath.addTupleShapeComponent();
+        hadFulfillment |= searchShapeRequirement(IGM, packType, source,
+                                                 std::move(argPath));
+
+      }
+
+      return hadFulfillment;
+    }
+  }
+
   // TODO: functions
   // TODO: metatypes
 

lib/IRGen/GenPack.cpp

@@ -1408,4 +1408,47 @@ irgen::emitDynamicFunctionParameterFlags(IRGenFunction &IGF,
   (void) visitPackExplosion(IGF, packType, visitFn);
 
   return array;
-}
+}
+
+std::pair<StackAddress, llvm::Value *>
+irgen::emitInducedTupleTypeMetadataPack(
+    IRGenFunction &IGF, llvm::Value *tupleMetadata) {
+  auto *shape = emitTupleTypeMetadataLength(IGF, tupleMetadata);
+
+  auto pack = IGF.emitDynamicAlloca(IGF.IGM.TypeMetadataPtrTy, shape,
+                                    IGF.IGM.getPointerAlignment(),
+                                    /*allowTaskAlloc=*/true);
+  auto elementForIndex =
+    [&](llvm::Value *index) -> llvm::Value * {
+      return irgen::emitTupleTypeMetadataElementType(IGF, tupleMetadata, index);
+    };
+
+  auto *index = llvm::ConstantInt::get(IGF.IGM.SizeTy, 0);
+  emitPackExpansionPack(IGF, pack.getAddress(), index, shape,
+                        elementForIndex);
+
+  IGF.recordStackPackMetadataAlloc(pack, shape);
+
+  return {pack, shape};
+}
+
+MetadataResponse
+irgen::emitInducedTupleTypeMetadataPackRef(
+    IRGenFunction &IGF, CanPackType packType,
+    llvm::Value *tupleMetadata) {
+  StackAddress pack;
+  llvm::Value *shape;
+  std::tie(pack, shape) = emitInducedTupleTypeMetadataPack(
+      IGF, tupleMetadata);
+
+  auto *metadata = pack.getAddress().getAddress();
+
+  if (!IGF.canStackPromotePackMetadata()) {
+    metadata = IGF.Builder.CreateCall(
+        IGF.IGM.getAllocateMetadataPackFunctionPointer(), {metadata, shape});
+
+    cleanupTypeMetadataPack(IGF, pack, shape);
+  }
+
+  return MetadataResponse::forComplete(metadata);
+}

lib/IRGen/GenPack.h

@@ -126,6 +126,15 @@ emitDynamicFunctionParameterFlags(IRGenFunction &IGF,
                                   CanPackType packType,
                                   llvm::Value *shapeExpression);
 
+std::pair<StackAddress, llvm::Value *>
+emitInducedTupleTypeMetadataPack(
+    IRGenFunction &IGF, llvm::Value *tupleMetadata);
+
+MetadataResponse
+emitInducedTupleTypeMetadataPackRef(
+    IRGenFunction &IGF, CanPackType packType,
+    llvm::Value *tupleMetadata);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/GenProto.cpp

@@ -72,6 +72,7 @@
 #include "GenPack.h"
 #include "GenPointerAuth.h"
 #include "GenPoly.h"
+#include "GenTuple.h"
 #include "GenType.h"
 #include "GenericRequirement.h"
 #include "IRGenDebugInfo.h"
@@ -3184,6 +3185,38 @@ MetadataResponse MetadataPath::followComponent(IRGenFunction &IGF,
     return MetadataResponse::forComplete(capturedWTable);
   }
 
+  case Component::Kind::TuplePack: {
+    assert(component.getPrimaryIndex() == 0);
+
+    auto tupleType = cast<TupleType>(sourceKey.Type);
+    auto packType = tupleType.getInducedPackType();
+
+    sourceKey.Kind = LocalTypeDataKind::forFormalTypeMetadata();
+    sourceKey.Type = packType;
+
+    if (!source) return MetadataResponse();
+
+    auto sourceMetadata = source.getMetadata();
+    return emitInducedTupleTypeMetadataPackRef(IGF, packType,
+                                               sourceMetadata);
+  }
+
+  case Component::Kind::TupleShape: {
+    assert(component.getPrimaryIndex() == 0);
+
+    auto tupleType = cast<TupleType>(sourceKey.Type);
+
+    sourceKey.Kind = LocalTypeDataKind::forPackShapeExpression();
+    sourceKey.Type = tupleType.getInducedPackType();
+
+    if (!source) return MetadataResponse();
+
+    auto sourceMetadata = source.getMetadata();
+    auto count = irgen::emitTupleTypeMetadataLength(IGF, sourceMetadata);
+
+    return MetadataResponse::forComplete(count);
+  }
+
   case Component::Kind::Impossible:
     llvm_unreachable("following an impossible path!");
 
@@ -3222,11 +3255,17 @@ void MetadataPath::print(llvm::raw_ostream &out) const {
       out << "pack_expansion_count[" << component.getPrimaryIndex() << "]";
       break;
     case Component::Kind::PackExpansionPattern:
-      out << "pack_expansion_patttern[" << component.getPrimaryIndex() << "]";
+      out << "pack_expansion_pattern[" << component.getPrimaryIndex() << "]";
       break;
     case Component::Kind::ConditionalConformance:
       out << "conditional_conformance[" << component.getPrimaryIndex() << "]";
       break;
+    case Component::Kind::TuplePack:
+      out << "tuple_pack";
+      break;
+    case Component::Kind::TupleShape:
+      out << "tuple_shape";
+      break;
     case Component::Kind::Impossible:
       out << "impossible";
       break;

lib/IRGen/GenTuple.cpp

@@ -667,4 +667,33 @@ llvm::Constant *irgen::getTupleLabelsString(IRGenModule &IGM,
   // Otherwise, create a new string literal.
   // This method implicitly adds a null terminator.
   return IGM.getAddrOfGlobalString(buffer);
+}
+
+llvm::Value *irgen::emitTupleTypeMetadataLength(IRGenFunction &IGF,
+                                                llvm::Value *metadata) {
+  llvm::Value *indices[] = {
+      IGF.IGM.getSize(Size(0)),                   // (*tupleType)
+      llvm::ConstantInt::get(IGF.IGM.Int32Ty, 1)  //   .NumElements
+  };
+  auto slot = IGF.Builder.CreateInBoundsGEP(IGF.IGM.TupleTypeMetadataTy,
+                                            metadata, indices);
+
+  return IGF.Builder.CreateLoad(slot, IGF.IGM.SizeTy,
+                                IGF.IGM.getPointerAlignment());
+}
+
+llvm::Value *irgen::emitTupleTypeMetadataElementType(IRGenFunction &IGF,
+                                                     llvm::Value *metadata,
+                                                     llvm::Value *index) {
+  llvm::Value *indices[] = {
+      IGF.IGM.getSize(Size(0)),                   // (*tupleType)
+      llvm::ConstantInt::get(IGF.IGM.Int32Ty, 3), //   .Elements
+      index,                                      //     [index]
+      llvm::ConstantInt::get(IGF.IGM.Int32Ty, 0)  //       .Metadata
+  };
+  auto slot = IGF.Builder.CreateInBoundsGEP(IGF.IGM.TupleTypeMetadataTy,
+                                            metadata, indices);
+
+  return IGF.Builder.CreateLoad(slot, IGF.IGM.SizeTy,
+                                IGF.IGM.getPointerAlignment());
 }

lib/IRGen/GenTuple.h

@@ -72,6 +72,13 @@ namespace irgen {
   llvm::Constant *getTupleLabelsString(IRGenModule &IGM,
                                        CanTupleType type);
 
+  /// Load the NumElements of a tuple type metadata.
+  llvm::Value *emitTupleTypeMetadataLength(IRGenFunction &IGF,
+                                           llvm::Value *metadata);
+
+  llvm::Value *emitTupleTypeMetadataElementType(IRGenFunction &IGF,
+                                                llvm::Value *metadata,
+                                                llvm::Value *index);
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/MetadataPath.h

@@ -73,7 +73,13 @@ class MetadataPath {
       /// The count type of a pack expansion at index P in a pack.
       PackExpansionCount,
 
-      LastWithPrimaryIndex = PackExpansionCount,
+      /// Materialize tuple as a pack.
+      TuplePack,
+
+      /// Materialize length of tuple as a pack shape expression.
+      TupleShape,
+
+      LastWithPrimaryIndex = TupleShape,
 
       // Everything past this point has no index.
 
@@ -117,8 +123,10 @@ class MetadataPath {
       case Kind::NominalTypeArgumentShape:
       case Kind::NominalTypeArgument:
       case Kind::ConditionalConformance:
+      case Kind::TupleShape:
         return OperationCost::Load;
 
+      case Kind::TuplePack:
       case Kind::AssociatedConformance:
         return OperationCost::Call;
 
@@ -210,6 +218,14 @@ class MetadataPath {
     Path.push_back(Component(Component::Kind::PackExpansionCount, index));
   }
 
+  void addTuplePackComponent() {
+    Path.push_back(Component(Component::Kind::TuplePack, /*index=*/0));
+  }
+
+  void addTupleShapeComponent() {
+    Path.push_back(Component(Component::Kind::TupleShape, /*index=*/0));
+  }
+
   /// Return an abstract measurement of the cost of this path.
   OperationCost cost() const {
     auto cost = OperationCost::Free;

test/IRGen/tuple_conformances.swift

@@ -3,27 +3,37 @@
 import Swift
 
 protocol P {
-  func f()
+  func defaultRequirement()
+  static func staticRequirement()
 }
 
 extension P {
-  func f() {}
+  func defaultRequirement() {}
 }
 
 extension Builtin.TheTupleType: P where repeat each Elements: P {
+  static func staticRequirement() {}
 }
 
 func takesP<T: P>(_ t: T) {
-  t.f()
+  t.defaultRequirement()
+  T.staticRequirement()
 }
 
-struct S: P {}
+struct S: P {
+  static func staticRequirement() {
+    print(self)
+  }
+}
 
 func use() {
+  takesP(())
   takesP((S(), S()))
 }
 
-// CHECK-LABEL: define internal swiftcc void @"$sxxQp_t18tuple_conformances1PA2aBP1fyyFTW"({{i32|i64}} %0, ptr %"{{.*}}", ptr {{.*}} swiftself %1, ptr %Self, ptr %SelfWitnessTable) {{.*}} {
+// CHECK-LABEL: define internal swiftcc void @"$sxxQp_t18tuple_conformances1PA2aBP18defaultRequirementyyFTW"(ptr {{.*}} swiftself %0, ptr %Self, ptr %SelfWitnessTable) {{.*}} {
+
+// CHECK-LABEL: define internal swiftcc void @"$sxxQp_t18tuple_conformances1PA2aBP17staticRequirementyyFZTW"(ptr swiftself %0, ptr %Self, ptr %SelfWitnessTable) {{.*}} {
 
 // CHECK-LABEL: define hidden swiftcc void @"$s18tuple_conformances3useyyF"() {{.*}} {
 // CHECK: call ptr @"$s18tuple_conformances1SV_ACtxxQp_tAA1PAAWl"()