Closures and local functions only capture generic parameters if necessary

The CaptureInfo computed by Sema now records if the body of the
function uses any generic parameters from the outer context.
SIL type lowering only adds a generic signature if this is the
case, instead of unconditionally.

This might yield a marginal performance improvement in some cases,
but more interestingly will allow @convention(c) conversions from
generic context.

Swift SVN r32161

Author: slavapestov

include/swift/AST/AnyFunctionRef.h

@@ -66,6 +66,12 @@ class AnyFunctionRef {
       return AFD->getBodyParamPatterns();
     return TheFunction.get<AbstractClosureExpr *>()->getParamPatterns();
   }
+  
+  bool hasType() const {
+    if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())
+      return AFD->hasType();
+    return !TheFunction.get<AbstractClosureExpr *>()->getType().isNull();
+  }
 
   Type getType() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>())

include/swift/AST/CaptureInfo.h

@@ -68,18 +68,24 @@ class CapturedValue {
 
 /// \brief Stores information about captured variables.
 class CaptureInfo {
-  llvm::PointerIntPair<const CapturedValue *, 1, bool> CapturesAndComputed;
-  size_t Count = 0;
+  const CapturedValue *Captures;
+  unsigned Count = 0;
+  bool GenericParamCaptures : 1;
+  bool Computed : 1;
 
 public:
-  bool hasBeenComputed() { return CapturesAndComputed.getInt(); }
+  CaptureInfo()
+    : Captures(nullptr), Count(0), GenericParamCaptures(0), Computed(0) { }
+
+  bool hasBeenComputed() { return Computed; }
   bool empty() { return Count == 0; }
 
   ArrayRef<CapturedValue> getCaptures() const {
-    return llvm::makeArrayRef(CapturesAndComputed.getPointer(), Count);
+    return llvm::makeArrayRef(Captures, Count);
   }
   void setCaptures(ArrayRef<CapturedValue> C) {
-    CapturesAndComputed.setPointerAndInt(C.data(), true);
+    Captures = C.data();
+    Computed = true;
     Count = C.size();
   }
 
@@ -92,6 +98,15 @@ class CaptureInfo {
   /// \returns true if getLocalCaptures() will return a non-empty list.
   bool hasLocalCaptures() const;
 
+  /// \returns true if the function captures any generic type parameters.
+  bool hasGenericParamCaptures() {
+    return GenericParamCaptures;
+  }
+
+  void setGenericParamCaptures(bool genericParamCaptures) {
+    GenericParamCaptures = genericParamCaptures;
+  }
+
   void dump() const;
   void print(raw_ostream &OS) const;
 };

include/swift/SIL/TypeLowering.h

@@ -14,6 +14,7 @@
 #define SIL_TypeLowering_h
 
 #include "swift/AST/ArchetypeBuilder.h"
+#include "swift/AST/CaptureInfo.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/SIL/AbstractionPattern.h"
 #include "swift/SIL/SILLocation.h"
@@ -389,6 +390,12 @@ struct SILConstantInfo {
     return SILType::getPrimitiveObjectType(SILFnType);
   }
 
+  ArrayRef<Substitution> getForwardingSubstitutions(ASTContext &C) {
+    if (!ContextGenericParams)
+      return { };
+    return ContextGenericParams->getForwardingSubstitutions(C);
+  }
+
   friend bool operator==(SILConstantInfo lhs, SILConstantInfo rhs) {
     return lhs.FormalType == rhs.FormalType &&
            lhs.FormalInterfaceType == rhs.FormalInterfaceType &&
@@ -521,7 +528,7 @@ class TypeConverter {
 
   llvm::DenseMap<OverrideKey, SILConstantInfo> ConstantOverrideTypes;
 
-  llvm::DenseMap<AnyFunctionRef, std::vector<CapturedValue>> LoweredCaptures;
+  llvm::DenseMap<AnyFunctionRef, CaptureInfo> LoweredCaptures;
 
   /// The set of recursive types we've already diagnosed.
   llvm::DenseSet<NominalTypeDecl *> RecursiveNominalTypes;
@@ -781,8 +788,13 @@ class TypeConverter {
   /// Retrieve the set of archetypes open in the given context.
   GenericParamList *getEffectiveGenericParamsForContext(DeclContext *dc);
 
-  /// Retrieve the set of generic parameters for the given context.
-  CanGenericSignature getEffectiveGenericSignatureForContext(DeclContext *dc);
+  /// Retrieve the set of archetypes closed over by the given function.
+  GenericParamList *getEffectiveGenericParams(AnyFunctionRef fn,
+                                              CaptureInfo captureInfo);
+
+  /// Retrieve the set of generic parameters closed over by the given function.
+  CanGenericSignature getEffectiveGenericSignature(AnyFunctionRef fn,
+                                                   CaptureInfo captureInfo);
 
   /// Push a generic function context. See GenericContextScope for an RAII
   /// interface to this function.
@@ -827,10 +839,10 @@ class TypeConverter {
   static SILLinkage getLinkageForProtocolConformance(
                                              const NormalProtocolConformance *C,
                                              ForDefinition_t definition);
-  
+
   /// Get the capture list from a closure, with transitive function captures
   /// flattened.
-  ArrayRef<CapturedValue> getLoweredLocalCaptures(AnyFunctionRef fn);
+  CaptureInfo getLoweredLocalCaptures(AnyFunctionRef fn);
 
   enum class ABIDifference : uint8_t {
     // No ABI differences, function can be trivially bitcast to result type.

lib/SIL/SILFunctionType.cpp

@@ -19,6 +19,7 @@
 #define DEBUG_TYPE "libsil"
 #include "swift/SIL/SILType.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/AST/AnyFunctionRef.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticsSIL.h"
 #include "swift/AST/ForeignErrorConvention.h"

lib/SIL/TypeLowering.cpp

@@ -1855,8 +1855,34 @@ TypeConverter::getEffectiveGenericParamsForContext(DeclContext *dc) {
   return dc->getGenericParamsOfContext();
 }
 
+GenericParamList *
+TypeConverter::getEffectiveGenericParams(AnyFunctionRef fn,
+                                         CaptureInfo captureInfo) {
+  auto dc = fn.getAsDeclContext()->getParent();
+
+  if (dc->isLocalContext() &&
+      !captureInfo.hasGenericParamCaptures()) {
+    return nullptr;
+  }
+
+  return getEffectiveGenericParamsForContext(dc);
+}
+
 CanGenericSignature
-TypeConverter::getEffectiveGenericSignatureForContext(DeclContext *dc) {
+TypeConverter::getEffectiveGenericSignature(AnyFunctionRef fn,
+                                            CaptureInfo captureInfo) {
+  auto dc = fn.getAsDeclContext();
+
+  if (auto sig = dc->getGenericSignatureOfContext())
+    return sig->getCanonicalSignature();
+
+  dc = dc->getParent();
+
+  if (dc->isLocalContext() &&
+      !captureInfo.hasGenericParamCaptures()) {
+    return nullptr;
+  }
+
   // Find the innermost context that has a generic parameter list.
   // FIXME: This is wrong for generic local functions in generic contexts.
   // Their GenericParamList is not semantically a child of the context
@@ -1876,11 +1902,16 @@ TypeConverter::getEffectiveGenericSignatureForContext(DeclContext *dc) {
 CanAnyFunctionType
 TypeConverter::getFunctionTypeWithCaptures(CanAnyFunctionType funcType,
                                            AnyFunctionRef theClosure) {
-  auto parentContext = theClosure.getAsDeclContext()->getParent();
-  // Capture generic parameters from the enclosing context.
-  GenericParamList *genericParams
-    = getEffectiveGenericParamsForContext(parentContext);
-  
+  // Get transitive closure of value captured by this function, and any
+  // captured functions.
+  auto captureInfo = getLoweredLocalCaptures(theClosure);
+
+  // Capture generic parameters from the enclosing context if necessary.
+  GenericParamList *genericParams =
+      getEffectiveGenericParams(theClosure, captureInfo);
+
+  // If we don't have any local captures (including function captures),
+  // there's no context to apply.
   if (!theClosure.getCaptureInfo().hasLocalCaptures()) {
     if (!genericParams)
       return adjustFunctionType(funcType,
@@ -1900,12 +1931,7 @@ TypeConverter::getFunctionTypeWithCaptures(CanAnyFunctionType funcType,
 
   SmallVector<TupleTypeElt, 8> inputFields;
 
-  // Note that the list of lowered local captures may be empty even if
-  // CaptureInfo::hasLocalCaptures() returned true. This is the case if e.g.
-  // a local function calls another local function which has no captures itself.
-  ArrayRef<CapturedValue> captures = getLoweredLocalCaptures(theClosure);
-
-  for (auto capture : captures) {
+  for (auto capture : captureInfo.getCaptures()) {
     auto VD = capture.getDecl();
     // A capture of a 'var' or 'inout' variable is done with the underlying
     // object type.
@@ -1955,12 +1981,16 @@ TypeConverter::getFunctionTypeWithCaptures(CanAnyFunctionType funcType,
 CanAnyFunctionType
 TypeConverter::getFunctionInterfaceTypeWithCaptures(CanAnyFunctionType funcType,
                                                     AnyFunctionRef theClosure) {
-  auto context = theClosure.getAsDeclContext();
+  // Get transitive closure of value captured by this function, and any
+  // captured functions.
+  auto captureInfo = getLoweredLocalCaptures(theClosure);
 
-  // Capture generic parameters from the enclosing context.
-  CanGenericSignature genericSig
-    = getEffectiveGenericSignatureForContext(context);
+  // Capture generic parameters from the enclosing context if necessary.
+  CanGenericSignature genericSig = getEffectiveGenericSignature(theClosure,
+                                                                captureInfo);
 
+  // If we don't have any local captures (including function captures),
+  // there's no context to apply.
   if (!theClosure.getCaptureInfo().hasLocalCaptures()) {
     if (!genericSig)
       return adjustFunctionType(funcType,
@@ -1978,12 +2008,7 @@ TypeConverter::getFunctionInterfaceTypeWithCaptures(CanAnyFunctionType funcType,
 
   SmallVector<TupleTypeElt, 8> inputFields;
 
-  // Note that the list of lowered local captures may be empty even if
-  // CaptureInfo::hasLocalCaptures() returned true. This is the case if e.g.
-  // a local function calls another local function which has no captures itself.
-  ArrayRef<CapturedValue> captures = getLoweredLocalCaptures(theClosure);
-
-  for (auto capture : captures) {
+  for (auto capture : captureInfo.getCaptures()) {
     // A capture of a 'var' or 'inout' variable is done with the underlying
     // object type.
     auto vd = capture.getDecl();
@@ -2019,7 +2044,9 @@ TypeConverter::getFunctionInterfaceTypeWithCaptures(CanAnyFunctionType funcType,
     TupleType::get(inputFields, Context)->getCanonicalType();
 
   // Map context archetypes out of the captures.
-  capturedInputs = getInterfaceTypeOutOfContext(capturedInputs, context);
+  capturedInputs =
+      getInterfaceTypeOutOfContext(capturedInputs,
+                                   theClosure.getAsDeclContext());
 
   auto extInfo = AnyFunctionType::ExtInfo(FunctionType::Representation::Thin,
                                           /*noreturn*/ false,
@@ -2117,22 +2144,22 @@ TypeConverter::getConstantContextGenericParams(SILDeclRef c) {
   ValueDecl *vd = c.loc.dyn_cast<ValueDecl *>();
 
   /// Get the function generic params, including outer params.
-  auto getLocalFuncParams = [&](FuncDecl *func) -> GenericParamList * {
-    // FIXME: For local generic functions we need to chain the local generic
-    // context to the outer context.
-    if (auto GP = func->getGenericParamsOfContext())
-      return GP;
-    return getEffectiveGenericParamsForContext(func->getParent());
-  };
-  
   switch (c.kind) {
   case SILDeclRef::Kind::Func: {
     if (auto *ACE = c.getAbstractClosureExpr()) {
+      auto captureInfo = getLoweredLocalCaptures(ACE);
+
       // Closures are currently never natively generic.
-      return {getEffectiveGenericParamsForContext(ACE->getParent()), nullptr};
+      return {getEffectiveGenericParams(ACE, captureInfo), nullptr};
     }
     FuncDecl *func = cast<FuncDecl>(vd);
-    return {getLocalFuncParams(func), func->getGenericParams()};
+    // FIXME: For local generic functions we need to chain the local generic
+    // context to the outer context.
+    if (auto GP = func->getGenericParamsOfContext())
+      return {GP, func->getGenericParams()};
+    auto captureInfo = getLoweredLocalCaptures(func);
+    return {getEffectiveGenericParams(func, captureInfo),
+            func->getGenericParams()};
   }
   case SILDeclRef::Kind::EnumElement: {
     auto eltDecl = cast<EnumElementDecl>(vd);
@@ -2328,11 +2355,15 @@ getAnyFunctionRefFromCapture(CapturedValue capture) {
   return None;
 }
 
-ArrayRef<CapturedValue>
+CaptureInfo
 TypeConverter::getLoweredLocalCaptures(AnyFunctionRef fn) {
   // First, bail out if there are no local captures at all.
-  if (!fn.getCaptureInfo().hasLocalCaptures())
-    return {};
+  if (!fn.getCaptureInfo().hasLocalCaptures()) {
+    CaptureInfo info;
+    info.setGenericParamCaptures(
+        fn.getCaptureInfo().hasGenericParamCaptures());
+    return info;
+  };
 
   // See if we've cached the lowered capture list for this function.
   auto found = LoweredCaptures.find(fn);
@@ -2342,12 +2373,16 @@ TypeConverter::getLoweredLocalCaptures(AnyFunctionRef fn) {
   // Recursively collect transitive captures from captured local functions.
   llvm::DenseSet<AnyFunctionRef> visitedFunctions;
   llvm::SetVector<CapturedValue> captures;
+  bool capturesGenericParams = false;
 
   std::function<void (AnyFunctionRef)> collectFunctionCaptures
   = [&](AnyFunctionRef curFn) {
     if (!visitedFunctions.insert(curFn).second)
       return;
 
+    if (curFn.getCaptureInfo().hasGenericParamCaptures())
+      capturesGenericParams = true;
+
     SmallVector<CapturedValue, 4> localCaptures;
     curFn.getCaptureInfo().getLocalCaptures(localCaptures);
     for (auto capture : localCaptures) {
@@ -2401,11 +2436,11 @@ TypeConverter::getLoweredLocalCaptures(AnyFunctionRef fn) {
   collectFunctionCaptures(fn);
 
   // Cache the uniqued set of transitive captures.
-  auto inserted = LoweredCaptures.insert({fn, {}});
+  auto inserted = LoweredCaptures.insert({fn, CaptureInfo()});
   assert(inserted.second && "already in map?!");
   auto &cachedCaptures = inserted.first->second;
-  std::copy(captures.begin(), captures.end(),
-            std::back_inserter(cachedCaptures));
+  cachedCaptures.setGenericParamCaptures(capturesGenericParams);
+  cachedCaptures.setCaptures(Context.AllocateCopy(captures));
 
   return cachedCaptures;
 }

lib/SILGen/SILGenApply.cpp

@@ -75,7 +75,7 @@ emitCapturesAsArgumentSource(SILGenFunction &gen,
   // The capture array should match the explosion schema of the closure's
   // first formal argument type.
   auto info = gen.SGM.Types.getConstantInfo(SILDeclRef::forAnyFunctionRef(fn));
-  auto subs = gen.getForwardingSubstitutions();
+  auto subs = info.getForwardingSubstitutions(gen.getASTContext());
   auto origFormalTy = info.FormalInterfaceType;
   CanFunctionType formalTy;
   if (!subs.empty()) {
@@ -1195,11 +1195,16 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         substFnType = captures.second;
         setSelfParam(std::move(captures.first), captures.second.getInput());
       }
-      
-      // Forward local substitutions to a local function.
-      if (afd->getParent()->isLocalContext()) {
-        subs = SGF.getForwardingSubstitutions();
-      }
+
+      // FIXME: We should be checking hasLocalCaptures() on the lowered
+      // captures in the constant info too, to generate more efficient
+      // code for mutually recursive local functions which otherwise
+      // capture no state.
+      auto constantInfo = SGF.getConstantInfo(constant);
+
+      // Forward local substitutions to a non-generic local function.
+      if (afd->getParent()->isLocalContext() && !afd->getGenericParams())
+        subs = constantInfo.getForwardingSubstitutions(SGF.getASTContext());
     }
 
     if (e->getDeclRef().isSpecialized()) {
@@ -1232,8 +1237,14 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       substFnType = captures.second;
       setSelfParam(std::move(captures.first), captures.second.getInput());
     }
-    subs = SGF.getForwardingSubstitutions();
 
+    // FIXME: We should be checking hasLocalCaptures() on the lowered
+    // captures in the constant info above, to generate more efficient
+    // code for mutually recursive local functions which otherwise
+    // capture no state.
+    auto constantInfo = SGF.getConstantInfo(constant);
+    subs = constantInfo.getForwardingSubstitutions(SGF.getASTContext());
+
     setCallee(Callee::forDirect(SGF, constant, substFnType, e));
     // If there are substitutions, add them, always at depth 0.
     if (!subs.empty())

lib/SILGen/SILGenExpr.cpp

@@ -1941,9 +1941,7 @@ RValue RValueEmitter::visitAbstractClosureExpr(AbstractClosureExpr *e,
 
   // Generate the closure value (if any) for the closure expr's function
   // reference.
-  return RValue(SGF, e,
-                SGF.emitClosureValue(e, SILDeclRef(e),
-                                     SGF.getForwardingSubstitutions(), e));
+  return RValue(SGF, e, SGF.emitClosureValue(e, SILDeclRef(e), e));
 }
 
 RValue RValueEmitter::