IRGen: Remove some dead code from NecessaryBindings.cpp

Author: slavapestov

lib/IRGen/GenProto.cpp

@@ -2920,14 +2920,6 @@ void NecessaryBindings::save(IRGenFunction &IGF, Address buffer) const {
 void NecessaryBindings::addTypeMetadata(CanType type) {
   assert(!isa<InOutType>(type));
 
-  // If the bindings are for an async function, we will always need the type
-  // metadata.  The opportunities to reconstruct it available in the context of
-  // partial apply forwarders are not available here.
-  if (forAsyncFunction()) {
-    addRequirement({type, nullptr});
-    return;
-  }
-
   // Bindings are only necessary at all if the type is dependent.
   if (!type->hasArchetype())
     return;
@@ -2995,21 +2987,12 @@ void NecessaryBindings::addProtocolConformance(CanType type,
         dyn_cast<SpecializedProtocolConformance>(concreteConformance);
     // The partial apply forwarder does not have the context to reconstruct
     // abstract conditional conformance requirements.
-    if (forPartialApply() && specializedConf) {
+    if (specializedConf) {
       addAbstractConditionalRequirements(specializedConf);
-    } else if (forAsyncFunction()) {
-      ProtocolDecl *protocol = conf.getRequirement();
-      GenericRequirement requirement;
-      requirement.TypeParameter = type;
-      requirement.Protocol = protocol;
-      std::pair<GenericRequirement, ProtocolConformanceRef> pair{requirement,
-                                                                 conf};
-      Conformances.insert(pair);
-      addRequirement({type, concreteConformance->getProtocol()});
     }
     return;
   }
-  assert(isa<ArchetypeType>(type) || forAsyncFunction());
+  assert(isa<ArchetypeType>(type));
 
   // TODO: pass something about the root conformance necessary to
   // reconstruct this.
@@ -3204,29 +3187,20 @@ void EmitPolymorphicArguments::emit(SubstitutionMap subs,
   }
 }
 
-NecessaryBindings NecessaryBindings::forAsyncFunctionInvocation(
-    IRGenModule &IGM, CanSILFunctionType origType, SubstitutionMap subs) {
-  return computeBindings(IGM, origType, subs,
-                         false /*forPartialApplyForwarder*/);
-}
-
 NecessaryBindings
 NecessaryBindings::forPartialApplyForwarder(IRGenModule &IGM,
                                           CanSILFunctionType origType,
                                           SubstitutionMap subs,
                                           bool considerParameterSources) {
   return computeBindings(IGM, origType, subs,
-                         true  /*forPartialApplyForwarder*/,
                          considerParameterSources);
 }
 
 NecessaryBindings NecessaryBindings::computeBindings(
     IRGenModule &IGM, CanSILFunctionType origType, SubstitutionMap subs,
-    bool forPartialApplyForwarder, bool considerParameterSources) {
+    bool considerParameterSources) {
 
   NecessaryBindings bindings;
-  bindings.kind =
-      forPartialApplyForwarder ? Kind::PartialApply : Kind::AsyncFunction;
 
   // Bail out early if we don't have polymorphic parameters.
   if (!hasPolymorphicParameters(origType))
@@ -3249,9 +3223,7 @@ NecessaryBindings NecessaryBindings::computeBindings(
     case MetadataSource::Kind::SelfMetadata:
       // Async functions pass the SelfMetadata and SelfWitnessTable parameters
       // along explicitly.
-      if (forPartialApplyForwarder) {
-        bindings.addTypeMetadata(getSubstSelfType(IGM, origType, subs));
-      }
+      bindings.addTypeMetadata(getSubstSelfType(IGM, origType, subs));
       continue;
 
     case MetadataSource::Kind::SelfWitnessTable:

lib/IRGen/NecessaryBindings.h

@@ -42,28 +42,11 @@ namespace swift {
 /// NecessaryBindings - The set of metadata that must be saved in
 /// order to perform some set of operations on a type.
 class NecessaryBindings {
-  enum class Kind {
-    /// Are the bindings to be computed for a partial apply forwarder.
-    /// In the case this is true we need to store/restore the conformance of a
-    /// specialized type with conditional conformance because the conditional
-    /// requirements are not available in the partial apply forwarder.
-    PartialApply,
-    AsyncFunction,
-  };
-  Kind kind;
   llvm::SetVector<GenericRequirement> RequirementsSet;
-  llvm::SmallVector<GenericRequirement, 2> RequirementsVector;
   llvm::DenseMap<GenericRequirement, ProtocolConformanceRef> Conformances;
 
   void addRequirement(GenericRequirement requirement) {
-    switch (kind) {
-    case Kind::PartialApply:
-      RequirementsSet.insert(requirement);
-      break;
-    case Kind::AsyncFunction:
-      RequirementsVector.push_back(requirement);
-      break;
-    }
+    RequirementsSet.insert(requirement);
   }
 
   void addAbstractConditionalRequirements(
@@ -74,9 +57,6 @@ class NecessaryBindings {
 
   /// Collect the necessary bindings to invoke a function with the given
   /// signature.
-  static NecessaryBindings
-  forAsyncFunctionInvocation(IRGenModule &IGM, CanSILFunctionType origType,
-                             SubstitutionMap subs);
   static NecessaryBindings forPartialApplyForwarder(IRGenModule &IGM,
                                                     CanSILFunctionType origType,
                                                     SubstitutionMap subs,
@@ -88,13 +68,7 @@ class NecessaryBindings {
 
   /// Get the requirement from the bindings at index i.
   const GenericRequirement &operator[](size_t i) const {
-    switch (kind) {
-    case Kind::PartialApply:
-      return RequirementsSet[i];
-    case Kind::AsyncFunction:
-      return RequirementsVector[i];
-    }
-    llvm_unreachable("covered switch");
+    return RequirementsSet[i];
   }
 
   ProtocolConformanceRef
@@ -124,23 +98,13 @@ class NecessaryBindings {
   void restore(IRGenFunction &IGF, Address buffer, MetadataState state) const;
 
   const llvm::ArrayRef<GenericRequirement> getRequirements() const {
-    switch (kind) {
-    case Kind::PartialApply:
-      return RequirementsSet.getArrayRef();
-    case Kind::AsyncFunction:
-      return RequirementsVector;
-    }
-    llvm_unreachable("unhandled case");
+    return RequirementsSet.getArrayRef();
   }
 
-  bool forPartialApply() const { return kind == Kind::PartialApply; }
-  bool forAsyncFunction() const { return kind == Kind::AsyncFunction; }
-
 private:
   static NecessaryBindings computeBindings(IRGenModule &IGM,
                                            CanSILFunctionType origType,
                                            SubstitutionMap subs,
-                                           bool forPartialApplyForwarder,
                                            bool considerParameterSources = true);
 };