IRGen: Simplify enumerateFulfillments()

Author: slavapestov

lib/IRGen/Fulfillment.cpp

@@ -279,38 +279,43 @@ bool FulfillmentMap::searchNominalTypeMetadata(IRGenModule &IGM,
 
   bool hadFulfillment = false;
 
+  auto subs = type->getContextSubstitutionMap(IGM.getSwiftModule(), nominal);
+
   GenericTypeRequirements requirements(IGM, nominal);
-  requirements.enumerateFulfillments(
-      IGM, type->getContextSubstitutionMap(IGM.getSwiftModule(), nominal),
-      [&](unsigned reqtIndex, CanType arg, ProtocolConformanceRef conf) {
-        // Skip uninteresting type arguments.
-        if (!keys.hasInterestingType(arg))
-          return;
-
-        // If the fulfilled value is type metadata, refine the path.
-        if (conf.isInvalid()) {
-          auto argState =
-              getPresumedMetadataStateForTypeArgument(metadataState);
-          MetadataPath argPath = path;
-          argPath.addNominalTypeArgumentComponent(reqtIndex);
-          hadFulfillment |= searchTypeMetadata(
-              IGM, arg, IsExact, argState, source, std::move(argPath), keys);
-          return;
-        }
-
-        // Otherwise, it's a conformance.
-
-        // Ignore it unless the type itself is interesting.
-        if (!keys.isInterestingType(arg))
-          return;
-
-        // Refine the path.
-        MetadataPath argPath = path;
-        argPath.addNominalTypeArgumentConformanceComponent(reqtIndex);
-
-        hadFulfillment |= searchWitnessTable(IGM, arg, conf.getRequirement(),
-                                             source, std::move(argPath), keys);
-      });
+
+  for (unsigned reqtIndex : indices(requirements.getRequirements())) {
+    auto requirement = requirements.getRequirements()[reqtIndex];
+    auto arg = requirement.getTypeParameter().subst(subs)->getCanonicalType();
+
+    // Skip uninteresting type arguments.
+    if (!keys.hasInterestingType(arg))
+      continue;
+
+    // If the fulfilled value is type metadata, refine the path.
+    if (requirement.isMetadata()) {
+      auto argState =
+          getPresumedMetadataStateForTypeArgument(metadataState);
+      MetadataPath argPath = path;
+      argPath.addNominalTypeArgumentComponent(reqtIndex);
+      hadFulfillment |= searchTypeMetadata(
+          IGM, arg, IsExact, argState, source, std::move(argPath), keys);
+      continue;
+    }
+
+    // Otherwise, it's a conformance.
+    assert(requirement.isWitnessTable());
+
+    // Ignore it unless the type itself is interesting.
+    if (!keys.isInterestingType(arg))
+      continue;
+
+    // Refine the path.
+    MetadataPath argPath = path;
+    argPath.addNominalTypeArgumentConformanceComponent(reqtIndex);
+
+    hadFulfillment |= searchWitnessTable(IGM, arg, requirement.getProtocol(),
+                                         source, std::move(argPath), keys);
+  }
 
   return hadFulfillment;
 }

lib/IRGen/GenProto.cpp

@@ -3154,8 +3154,8 @@ void EmitPolymorphicArguments::emit(SubstitutionMap subs,
   // For now, treat all archetypes independently.
   enumerateUnfulfilledRequirements([&](GenericRequirement requirement) {
     llvm::Value *requiredValue =
-      emitGenericRequirementFromSubstitutions(IGF, Generics,
-                                              requirement, subs);
+      emitGenericRequirementFromSubstitutions(IGF, requirement, subs,
+                                              MetadataState::Complete);
     out.add(requiredValue);
   });
 
@@ -3277,7 +3277,6 @@ GenericTypeRequirements::GenericTypeRequirements(IRGenModule &IGM,
 
   // Construct a representative function type.
   auto generics = ncGenerics.getCanonicalSignature();
-  Generics = generics;
   auto fnType = SILFunctionType::get(generics, SILFunctionType::ExtInfo(),
                                 SILCoroutineKind::None,
                                 /*callee*/ ParameterConvention::Direct_Unowned,
@@ -3297,35 +3296,15 @@ GenericTypeRequirements::GenericTypeRequirements(IRGenModule &IGM,
   // We do not need to consider extra sources.
 }
 
-void
-GenericTypeRequirements::enumerateFulfillments(IRGenModule &IGM,
-                                               SubstitutionMap subs,
-                                               FulfillmentCallback callback) {
-  if (empty()) return;
-
-  for (auto reqtIndex : indices(getRequirements())) {
-    auto &reqt = getRequirements()[reqtIndex];
-    CanType type = reqt.getTypeParameter().subst(subs)->getCanonicalType();
-    if (reqt.isWitnessTable()) {
-      auto conformance =
-          subs.lookupConformance(reqt.getTypeParameter(), reqt.getProtocol());
-      callback(reqtIndex, type, conformance);
-    } else {
-      assert(reqt.isMetadata());
-      callback(reqtIndex, type, ProtocolConformanceRef::forInvalid());
-    }
-  }
-}
-
 void GenericTypeRequirements::emitInitOfBuffer(IRGenFunction &IGF,
                                                SubstitutionMap subs,
                                                Address buffer) {
   if (Requirements.empty()) return;
 
   emitInitOfGenericRequirementsBuffer(IGF, Requirements, buffer,
                                       [&](GenericRequirement requirement) {
-    return emitGenericRequirementFromSubstitutions(IGF, Generics,
-                                                   requirement, subs);
+    return emitGenericRequirementFromSubstitutions(IGF, requirement, subs,
+                                                   MetadataState::Complete);
   });
 }
 
@@ -3358,9 +3337,9 @@ void irgen::emitInitOfGenericRequirementsBuffer(IRGenFunction &IGF,
 
 llvm::Value *
 irgen::emitGenericRequirementFromSubstitutions(IRGenFunction &IGF,
-                                               CanGenericSignature generics,
                                                GenericRequirement requirement,
-                                               SubstitutionMap subs) {
+                                               SubstitutionMap subs,
+                                               DynamicMetadataRequest request) {
   CanType depTy = requirement.getTypeParameter();
   CanType argType = depTy.subst(subs)->getCanonicalType();
 
@@ -3369,7 +3348,7 @@ irgen::emitGenericRequirementFromSubstitutions(IRGenFunction &IGF,
     return IGF.emitPackShapeExpression(argType);
 
   case GenericRequirement::Kind::Metadata:
-    return IGF.emitTypeMetadataRef(argType);
+    return IGF.emitTypeMetadataRef(argType, request).getMetadata();
 
   case GenericRequirement::Kind::WitnessTable: {
     auto proto = requirement.getProtocol();

lib/IRGen/GenericArguments.h

@@ -29,6 +29,7 @@
 #include "IRGenFunction.h"
 #include "IRGenMangler.h"
 #include "IRGenModule.h"
+#include "MetadataRequest.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
@@ -50,13 +51,7 @@ struct GenericArguments {
   SmallVector<llvm::Value *, 8> Values;
   SmallVector<llvm::Type *, 8> Types;
 
-  static unsigned getNumGenericArguments(IRGenModule &IGM,
-                                         NominalTypeDecl *nominal) {
-    GenericTypeRequirements requirements(IGM, nominal);
-    return requirements.getNumTypeRequirements();
-  }
-
-  void collectTypes(IRGenModule &IGM, NominalTypeDecl *nominal) {
+ void collectTypes(IRGenModule &IGM, NominalTypeDecl *nominal) {
     GenericTypeRequirements requirements(IGM, nominal);
     collectTypes(IGM, requirements);
   }
@@ -87,15 +82,10 @@ struct GenericArguments {
   void collect(IRGenFunction &IGF, SubstitutionMap subs) {
     GenericTypeRequirements requirements(IGF.IGM, subs.getGenericSignature());
 
-    requirements.enumerateFulfillments(
-        IGF.IGM, subs,
-        [&](unsigned reqtIndex, CanType type, ProtocolConformanceRef conf) {
-          if (conf) {
-            Values.push_back(emitWitnessTableRef(IGF, type, conf));
-          } else {
-            Values.push_back(IGF.emitAbstractTypeMetadataRef(type));
-          }
-        });
+    for (auto requirement : requirements.getRequirements()) {
+      Values.push_back(emitGenericRequirementFromSubstitutions(
+          IGF, requirement, subs, MetadataState::Abstract));
+    }
 
     collectTypes(IGF.IGM, requirements);
     assert(Types.size() == Values.size());

lib/IRGen/GenericRequirement.h

@@ -41,6 +41,7 @@ namespace irgen {
 class Address;
 class IRGenFunction;
 class IRGenModule;
+class DynamicMetadataRequest;
 
 using RequirementCallback =
   llvm::function_ref<void(GenericRequirement requirement)>;
@@ -54,9 +55,9 @@ void enumerateGenericSignatureRequirements(CanGenericSignature signature,
 /// value.
 llvm::Value *
 emitGenericRequirementFromSubstitutions(IRGenFunction &IGF,
-                                        CanGenericSignature signature,
                                         GenericRequirement requirement,
-                                        SubstitutionMap subs);
+                                        SubstitutionMap subs,
+                                        DynamicMetadataRequest request);
 
 using EmitGenericRequirementFn =
   llvm::function_ref<llvm::Value*(GenericRequirement reqt)>;
@@ -86,15 +87,10 @@ void bindFromGenericRequirementsBuffer(IRGenFunction &IGF,
 /// A class describing the layout of the generic requirements of a
 /// nominal type metadata.
 ///
-/// The generic requirements are always laid out as a sequence of type
-/// metadata (corresponding to the type parameters of the context established
-/// by the type, minus anything fulfillable from its parent type metadata)
-/// followed by a sequence of protocol witness tables (corresponding to the
-/// root conformances of the context established by the type, again minus
-/// anything fulfillable from its parent type metadata).
+/// The generic requirements are always laid out as a sequence of shape
+/// parameters, followed by type metadata and witness tables.
 class GenericTypeRequirements {
   llvm::SmallVector<GenericRequirement, 4> Requirements;
-  CanGenericSignature Generics;
 
 public:
   GenericTypeRequirements(IRGenModule &IGM, NominalTypeDecl *decl);
@@ -105,38 +101,8 @@ class GenericTypeRequirements {
     return Requirements;
   }
 
-  /// Return the number of entries required in order to store this data.
-  unsigned getStorageSizeInWords() const {
-    return Requirements.size();
-  }
-
-  /// Return the number of type metadata requirements.
-  unsigned getNumTypeRequirements() const {
-    unsigned count = 0;
-    for (auto i = Requirements.begin(), e = Requirements.end(); i != e; ++i) {
-      if (i->isMetadata()) {
-        count++;
-      } else {
-#ifndef NDEBUG
-        // Assert that the rest of the requirements are conformance
-        // requirements.
-        for (++i; i != e; ++i) {
-          assert(i->isWitnessTable() && "type requirement followed conformance!");
-        }
-#endif
-        break;
-      }
-    }
-    return count;
-  }
-
   bool empty() const { return Requirements.empty(); }
 
-  using FulfillmentCallback = llvm::function_ref<void(
-      unsigned requirementIndex, CanType type, ProtocolConformanceRef conf)>;
-  void enumerateFulfillments(IRGenModule &IGM, SubstitutionMap subs,
-                             FulfillmentCallback callback);
-
   void emitInitOfBuffer(IRGenFunction &IGF, SubstitutionMap subs,
                         Address buffer);
 

lib/IRGen/IRGenSIL.cpp

@@ -6543,8 +6543,8 @@ void IRGenSILFunction::visitKeyPathInst(swift::KeyPathInst *I) {
     if (!I->getSubstitutions().empty()) {
       emitInitOfGenericRequirementsBuffer(*this, requirements, argsBuf,
         [&](GenericRequirement reqt) -> llvm::Value * {
-          return emitGenericRequirementFromSubstitutions(*this, sig,
-                                                         reqt, subs);
+          return emitGenericRequirementFromSubstitutions(*this, reqt, subs,
+                                                         MetadataState::Complete);
         });
     }
 

test/IRGen/variadic_generic_types.swift

@@ -17,3 +17,12 @@ struct G<T...> {
     callee()
   }
 }
+
+func blackHole<T>(_: T) {}
+
+blackHole(G< >.self)
+blackHole(G<Int, String>.self)
+
+func genericMetadata<T...>(_: T...) {
+  blackHole(G<T... >.self)
+}