Implement arity reabstraction for closures

Author: rjmccall

lib/SIL/IR/AbstractionPattern.cpp

@@ -2310,10 +2310,13 @@ const {
   if (yieldType)
     yieldType = yieldType->getReducedType(substSig);
 
+  // Note that we specifically do not want to put subMap in the
+  // abstraction patterns here, because the types we will be lowering
+  // against them will not be substituted.
   return std::make_tuple(
-          AbstractionPattern(subMap, substSig, substTy->getReducedType(substSig)),
+          AbstractionPattern(substSig, substTy->getReducedType(substSig)),
           subMap,
           yieldType
-            ? AbstractionPattern(subMap, substSig, yieldType)
+            ? AbstractionPattern(substSig, yieldType)
             : AbstractionPattern::getInvalid());
 }

lib/SILGen/FunctionInputGenerator.h

@@ -0,0 +1,184 @@
+//===--- FunctionInputGenerator.h - Generator for formal params -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines FunctionInputGenerator, which generates the sequence
+// of formal parameters for a SIL function given its abstraction pattern,
+// informing the caller of important information such as the orig and subst
+// types and whether the parameter is passed as part of a pack.  (It's this
+// latter possibility that makes this relatively complicated.)
+//
+// The assumption is that this will be used as part of binding the parameters
+// for a function and that the client of the traversal will claim those
+// parameters one by one as the traversal goes on.
+//
+// In order to properly handle packs of parameters, and especially empty
+// packs of parameters, this generator must claim the pack parameters
+// as it goes.  As a result, it's actually quite important that clients
+// use the pattern above of claiming non-pack parameter values immediately
+// while traversing a parameter and before advancing to the next parameter.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILGEN_FUNCTIONINPUTGENERATOR_H
+#define SWIFT_SILGEN_FUNCTIONINPUTGENERATOR_H
+
+#include "ManagedValue.h"
+#include "swift/SIL/AbstractionPatternGenerators.h"
+#include "swift/AST/Types.h"
+#include "swift/Basic/Generators.h"
+
+namespace swift {
+namespace Lowering {
+
+/// A class for destructuring a list of formal input parameters given
+/// an abstraction pattern for it.
+class FunctionInputGenerator {
+  const ASTContext &ctx;
+  SimpleGeneratorRef<ManagedValue> inputs;
+  FunctionParamGenerator origParam;
+
+  /// If origParam.isPackExpansion(), this is the pack currently
+  /// being destructured.  The cleanup on it is only for the components
+  /// starting at substParamIndex.
+  ManagedValue packValue;
+
+  /// If origParam.isPackExpansion(), this is the formal type
+  /// of the orig parameter pack.
+  CanPackType formalPackType;
+
+  /// The current index within origParam.getSubstParams().
+  unsigned substParamIndex;
+
+  /// Precondition: we aren't finished visiting orig parameters,
+  /// and we've already readied the current orig parameter.
+  ///
+  /// Ready the next subst parameter (the one at inputSubstParamIndex)
+  /// from the current orig parameter.  If we've exhausted the supply
+  /// of subst parameters from this orig parameter, advance to the
+  /// next orig parameter and repeat.
+  ///
+  /// Postcondition: we're either finished or properly configured
+  /// with a subst parameter that hasn't been presented before.
+  void readyNextSubstParameter() {
+    while (true) {
+      assert(!origParam.isFinished());
+      assert(substParamIndex <= origParam.getSubstParams().size());
+
+      // If we haven't reached the limit of the current parameter yet,
+      // continue.
+      if (substParamIndex != origParam.getSubstParams().size())
+        return;
+
+      // Otherwise, advance, and ready the next orig parameter if we
+      // didn't finish.
+      origParam.advance();
+      if (origParam.isFinished()) return;
+      readyOrigParameter();
+    }
+  }
+
+  /// Ready the current orig parameter.
+  void readyOrigParameter() {
+    substParamIndex = 0;
+    if (origParam.isPackExpansion()) {
+      // The pack value exists in the lowered parameters and must be
+      // claimed whether it contains formal parameters or not.
+      packValue = inputs.claimNext();
+
+      // We don't need to do any other set up if we're going to
+      // immediately move past it, though.
+      if (origParam.getSubstParams().empty())
+        return;
+
+      // Compute a formal pack type for the pack.
+      formalPackType = CanPackType::get(ctx, origParam.getSubstParams());
+    }
+  }
+
+public:
+  FunctionInputGenerator(const ASTContext &ctx,
+                         SimpleGeneratorRef<ManagedValue> inputs,
+                         AbstractionPattern origFunctionType,
+                         AnyFunctionType::CanParamArrayRef substParams,
+                         bool ignoreFinalParam)
+    : ctx(ctx), inputs(inputs),
+      origParam(origFunctionType, substParams, ignoreFinalParam) {
+
+    if (!origParam.isFinished()) {
+      readyOrigParameter();
+      readyNextSubstParameter();
+    }
+  }
+
+  /// Is this generator finished?  If so, the getters below may not be used.
+  bool isFinished() const {
+    return origParam.isFinished();
+  }
+
+  bool isOrigPackExpansion() const {
+    return origParam.isPackExpansion();
+  }
+
+  AbstractionPattern getOrigType() const {
+    return origParam.getOrigType();
+  }
+
+  AnyFunctionType::CanParam getSubstParam() const {
+    return origParam.getSubstParams()[substParamIndex];
+  }
+
+  ManagedValue getPackValue() const {
+    assert(isOrigPackExpansion());
+    return packValue;
+  }
+
+  void updatePackValue(ManagedValue newPackValue) {
+    assert(isOrigPackExpansion());
+    packValue = newPackValue;
+  }
+
+  unsigned getPackComponentIndex() const {
+    assert(isOrigPackExpansion());
+    return substParamIndex;
+  }
+
+  CanPackType getFormalPackType() const {
+    assert(isOrigPackExpansion());
+    return formalPackType;
+  }
+
+  /// Given that we just processed an input, advance to the next,
+  /// if there is on.
+  ///
+  /// Postcondition: either isFinished() or all of the invariants
+  /// for the mutable state have been established.
+  void advance() {
+    assert(!isFinished());
+    assert(substParamIndex < origParam.getSubstParams().size());
+    substParamIndex++;
+
+    readyNextSubstParameter();
+  }
+
+  void finish() {
+    origParam.finish();
+  }
+
+  /// Project out the current pack component.  Do not call this multiple
+  /// times for the same component.
+  ManagedValue projectPackComponent(SILGenFunction &SGF, SILLocation loc);
+};
+
+} // end namespace Lowering
+} // end namespace swift
+
+#endif

lib/SILGen/SILGenFunction.cpp

@@ -687,7 +687,7 @@ void SILGenFunction::emitClosure(AbstractClosureExpr *ace) {
     SILDeclRef(ace));
   emitProlog(captureInfo, ace->getParameters(), /*selfParam=*/nullptr,
              ace, resultIfaceTy, ace->isBodyThrowing(), ace->getLoc(),
-             SGM.M.Types.getConstantAbstractionPattern(SILDeclRef(ace)));
+             OrigFnType);
   prepareEpilog(resultIfaceTy, ace->isBodyThrowing(), CleanupLocation(ace));
 
   emitProfilerIncrement(ace);