Fix fulfillments for type metadata and witness table packs

A lot of the fixes here are adjustments to compensate in the
fulfillment and metadata-path subsystems for the recent pack
substitutions representation change.  I think these adjustments
really make the case for why the change was the right one to make:
the code was clearly not considering the possibility of packs
in these positions, and the need to handle packs makes everything
work out much more cleanly.

There's still some work that needs to happen around type packs;
in particular, we're not caching them or fulfilling them as a
whole, and we do have the setup to do that properly now.

Author: rjmccall

include/swift/IRGen/GenericRequirement.h

@@ -82,6 +82,12 @@ class GenericRequirement {
   }
 
   bool isMetadata() const {
+    return kind == Kind::Metadata;
+  }
+  bool isMetadataPack() const {
+    return kind == Kind::MetadataPack;
+  }
+  bool isAnyMetadata() const {
     return kind == Kind::Metadata || kind == Kind::MetadataPack;
   }
 
@@ -94,6 +100,12 @@ class GenericRequirement {
   }
 
   bool isWitnessTable() const {
+    return kind == Kind::WitnessTable;
+  }
+  bool isWitnessTablePack() const {
+    return kind == Kind::WitnessTablePack;
+  }
+  bool isAnyWitnessTable() const {
     return kind == Kind::WitnessTable || kind == Kind::WitnessTablePack;
   }
 

lib/IRGen/Fulfillment.cpp

@@ -179,6 +179,46 @@ bool FulfillmentMap::searchTypeMetadata(IRGenModule &IGM, CanType type,
   return false;
 }
 
+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();
+}
+
+bool FulfillmentMap::searchTypeMetadataPack(IRGenModule &IGM,
+                                            CanPackType packType,
+                                            IsExact_t isExact,
+                                            MetadataState metadataState,
+                                            unsigned source,
+                                            MetadataPath &&path,
+                                      const InterestingKeysCallback &keys) {
+  // We can fulfill pack parameters if the pack is a singleton pack
+  // expansion over one.
+  // TODO: we can also fulfill pack expansions if we can slice away
+  // constant-sized prefixes and suffixes.
+  Optional<unsigned> packExpansionComponent;
+  if (auto parameter = getSingletonPackExpansionParameter(packType, keys,
+                                                    packExpansionComponent)) {
+    MetadataPath singletonPath = path;
+    singletonPath.addPackExpansionPatternComponent(*packExpansionComponent);
+    return addFulfillment(GenericRequirement::forMetadata(parameter),
+                          source, std::move(singletonPath), metadataState);
+  }
+
+  // TODO: fulfill non-expansion metadata out of the pack
+
+  // TODO: fulfill the pack type itself
+
+  return false;
+}
+
 bool FulfillmentMap::searchConformance(
     IRGenModule &IGM, const ProtocolConformance *conformance,
     unsigned sourceIndex, MetadataPath &&path,
@@ -297,10 +337,8 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
       MetadataPath argPath = path;
       argPath.addNominalTypeArgumentShapeComponent(reqtIndex);
 
-      // Add the fulfillment.
-      hadFulfillment |= addFulfillment(GenericRequirement::forShape(arg),
-                                       source, std::move(argPath),
-                                       MetadataState::Complete);
+      hadFulfillment |= searchShapeRequirement(IGM, arg, source,
+                                               std::move(argPath));
       break;
     }
     case GenericRequirement::Kind::Metadata:
@@ -310,22 +348,44 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
           getPresumedMetadataStateForTypeArgument(metadataState);
       MetadataPath argPath = path;
       argPath.addNominalTypeArgumentComponent(reqtIndex);
-      hadFulfillment |= searchTypeMetadata(
-          IGM, arg, IsExact, argState, source, std::move(argPath), keys);
+
+      if (requirement.getKind() == GenericRequirement::Kind::Metadata)
+        hadFulfillment |=
+          searchTypeMetadata(IGM, arg, IsExact, argState,
+                              source, std::move(argPath), keys);
+      else
+        hadFulfillment |=
+          searchTypeMetadataPack(IGM, cast<PackType>(arg), IsExact, argState,
+                                 source, std::move(argPath), keys);
       break;
     }
-    case GenericRequirement::Kind::WitnessTable:
-    case GenericRequirement::Kind::WitnessTablePack: {
-      // Ignore it unless the type itself is interesting.
-      if (!keys.isInterestingType(arg))
-        continue;
+    case GenericRequirement::Kind::WitnessTablePack:
+    case GenericRequirement::Kind::WitnessTable: {
+      Optional<unsigned> packExpansionComponent;
+      if (requirement.getKind() == GenericRequirement::Kind::WitnessTable) {
+        // Ignore it unless the type itself is interesting.
+        if (!keys.isInterestingType(arg))
+          continue;
+      } else {
+        // Ignore it unless the pack is a singleton pack expansion of a
+        // type parameter, in which case use that type below.
+        auto param =
+            getSingletonPackExpansionParameter(cast<PackType>(arg), keys,
+                                               packExpansionComponent);
+        if (!param) continue;
+        arg = param;
+      }
 
       // Refine the path.
       MetadataPath argPath = path;
       argPath.addNominalTypeArgumentConformanceComponent(reqtIndex);
+      if (packExpansionComponent)
+        argPath.addPackExpansionPatternComponent(*packExpansionComponent);
 
-      hadFulfillment |= searchWitnessTable(IGM, arg, requirement.getProtocol(),
-                                           source, std::move(argPath), keys);
+      // This code just handles packs directly.
+      hadFulfillment |=
+        searchWitnessTable(IGM, arg, requirement.getProtocol(),
+                           source, std::move(argPath), keys);
       break;
     }
     }
@@ -334,6 +394,33 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
   return hadFulfillment;
 }
 
+bool FulfillmentMap::searchShapeRequirement(IRGenModule &IGM, CanType argType,
+                                            unsigned source, MetadataPath &&path) {
+  // argType is the substitution for a pack parameter, so it should always
+  // be a pack.
+  auto packType = cast<PackType>(argType);
+
+  // For now, don't try to fulfill shapes if this isn't a singleton
+  // pack containing a pack expansion.  In theory, though, as long as
+  // 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));
+  if (!expansion)
+    return false;
+
+  path.addPackExpansionCountComponent(0);
+
+  auto parameter = expansion.getCountType();
+  
+  // Add the fulfillment.
+  return addFulfillment(GenericRequirement::forShape(parameter),
+                        source, std::move(path), MetadataState::Complete);
+}
+
 /// Testify that there's a fulfillment at the given path.
 bool FulfillmentMap::addFulfillment(GenericRequirement key,
                                     unsigned source,

lib/IRGen/Fulfillment.h

@@ -62,6 +62,10 @@ class FulfillmentMap {
     /// It's okay to conservatively return true here.
     virtual bool hasInterestingType(CanType type) const = 0;
 
+    /// Is the given pack expansion a simple expansion of an interesting
+    /// type?
+    virtual bool isInterestingPackExpansion(CanPackExpansionType type) const = 0;
+
     /// Are we only interested in a subset of the conformances for a
     /// given type?
     virtual bool hasLimitedInterestingConformances(CanType type) const = 0;
@@ -98,6 +102,15 @@ class FulfillmentMap {
                           unsigned sourceIndex, MetadataPath &&path,
                           const InterestingKeysCallback &interestingKeys);
 
+  /// Search the given type metadata pack for useful fulfillments.
+  ///
+  /// \return true if any fulfillments were added by this search.
+  bool searchTypeMetadataPack(IRGenModule &IGM, CanPackType type,
+                              IsExact_t isExact,
+                              MetadataState metadataState,
+                              unsigned sourceIndex, MetadataPath &&path,
+                              const InterestingKeysCallback &interestingKeys);
+
   bool searchConformance(IRGenModule &IGM,
                          const ProtocolConformance *conformance,
                          unsigned sourceIndex, MetadataPath &&path,
@@ -110,6 +123,10 @@ class FulfillmentMap {
                           unsigned sourceIndex, MetadataPath &&path,
                           const InterestingKeysCallback &interestingKeys);
 
+  /// Consider a shape requirement for the given type.
+  bool searchShapeRequirement(IRGenModule &IGM, CanType type,
+                              unsigned sourceIndex, MetadataPath &&path);
+
   /// Register a fulfillment for the given key.
   ///
   /// \return true if the fulfillment was added, which won't happen if there's

lib/IRGen/GenArchetype.cpp

@@ -442,13 +442,13 @@ withOpaqueTypeGenericArgs(IRGenFunction &IGF,
         [&](GenericRequirement reqt) {
           auto ty = reqt.getTypeParameter().subst(archetype->getSubstitutions())
                         ->getReducedType(opaqueDecl->getGenericSignature());
-          if (reqt.isWitnessTable()) {
+          if (reqt.isAnyWitnessTable()) {
             auto ref =
                 ProtocolConformanceRef(reqt.getProtocol())
                     .subst(reqt.getTypeParameter(), archetype->getSubstitutions());
             args.push_back(emitWitnessTableRef(IGF, ty, ref));
           } else {
-            assert(reqt.isMetadata());
+            assert(reqt.isAnyMetadata());
             args.push_back(IGF.emitAbstractTypeMetadataRef(ty));
           }
           types.push_back(args.back()->getType());

lib/IRGen/GenKeyPath.cpp

@@ -896,12 +896,12 @@ emitKeyPathComponent(IRGenModule &IGM,
                 return None;
               })->getCanonicalType();
 
-              if (reqt.isMetadata()) {
+              if (reqt.isAnyMetadata()) {
                 // Type requirement.
                 externalSubArgs.push_back(emitMetadataTypeRefForKeyPath(
                     IGM, substType, componentCanSig));
               } else {
-                assert(reqt.isWitnessTable());
+                assert(reqt.isAnyWitnessTable());
 
                 // Protocol requirement.
                 auto conformance = subs.lookupConformance(

lib/IRGen/GenMeta.cpp

@@ -4432,15 +4432,15 @@ namespace {
     }
 
     void addGenericRequirement(GenericRequirement requirement) {
-      if (requirement.isMetadata()) {
+      if (requirement.isAnyMetadata()) {
         auto t = requirement.getTypeParameter().subst(genericSubstitutions());
         ConstantReference ref = IGM.getAddrOfTypeMetadata(
             CanType(t), SymbolReferenceKind::Relative_Direct);
         this->B.add(ref.getDirectValue());
         return;
       }
 
-      assert(requirement.isWitnessTable());
+      assert(requirement.isAnyWitnessTable());
       auto conformance = genericSubstitutions().lookupConformance(
           requirement.getTypeParameter()->getCanonicalType(),
           requirement.getProtocol());

lib/IRGen/GenMeta.h

@@ -121,6 +121,15 @@ namespace irgen {
                                        unsigned reqtIndex,
                                        llvm::Value *metadata);
 
+  /// Given a reference to nominal type metadata of the given type,
+  /// derive a reference to the type metadata pack stored in the nth
+  /// requirement slot.  The type must have generic arguments.
+  llvm::Value *emitArgumentMetadataPackRef(IRGenFunction &IGF,
+                                           NominalTypeDecl *theDecl,
+                                           const GenericTypeRequirements &reqts,
+                                           unsigned reqtIndex,
+                                           llvm::Value *metadata);
+
   /// Given a reference to nominal type metadata of the given type,
   /// derive a reference to a protocol witness table stored in the nth
   /// requirement slot.  The type must have generic arguments.
@@ -130,6 +139,15 @@ namespace irgen {
                                            unsigned reqtIndex,
                                            llvm::Value *metadata);
 
+  /// Given a reference to nominal type metadata of the given type,
+  /// derive a reference to a protocol witness table pack stored in the nth
+  /// requirement slot.  The type must have generic arguments.
+  llvm::Value *emitArgumentWitnessTablePackRef(IRGenFunction &IGF,
+                                               NominalTypeDecl *theDecl,
+                                           const GenericTypeRequirements &reqts,
+                                               unsigned reqtIndex,
+                                               llvm::Value *metadata);
+
   /// Given a reference to nominal type metadata of the given type,
   /// derive a reference to a the pack shape stored in the nth
   /// requirement slot.  The type must have generic arguments.