[NFC] Provide a more generator-like interface for traversing orig+subst function parameters

This is necessary because the use patterns in SILGenPoly require
walking two orig+subst sequences in parallel, which poses problems
for a callback-centric design like the one I addded before.  An
inversion of control is necessary; this is basically a manual
coroutine.  But frankly it's a nicer interface than the callback
design, too; I switched the implementation of forEachFunctionParam
to use the generator just to avoid code duplication, but I might
try to remove it and switch all the clients over to the generator.
The main problems with the callback design are that (1) I wasn't
sure which values clients would want, and the result is that there
are a *lot* of parameters and (2) (relatedly) the types of those
parameters have to be written out explicitly, and some of them
are quite large.  The generator code is just much nicer.  Maybe
I can still give the generator a little unparameterized callback
to keep lexical loops simple.

I'll need to do this same thing for tuples.  One at a time.

Author: rjmccall

include/swift/SIL/AbstractionPatternGenerators.h

@@ -0,0 +1,154 @@
+//===--- AbstractionPatternGenerators.h -------------------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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 "generators" that can be used with an AbstractionPattern
+// to do certain kinds of traversal without using callbacks.
+// This can be useful when a traversal is required in parallel with
+// some other traversal.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_ABSTRACTIONPATTERNGENERATORS_H
+#define SWIFT_SIL_ABSTRACTIONPATTERNGENERATORS_H
+
+#include "swift/SIL/AbstractionPattern.h"
+
+namespace swift {
+namespace Lowering {
+
+/// A generator for traversing the formal function parameters of a type
+/// while properly respecting variadic generics.
+class FunctionParamGenerator {
+  // The steady state of the generator.
+
+  /// The abstraction pattern of the entire function type.  Set once
+  /// during construction.
+  AbstractionPattern origFunctionType;
+
+  /// The list of all substituted parameters to traverse.  Set once
+  /// during construction.
+  AnyFunctionType::CanParamArrayRef allSubstParams;
+
+  /// The number of orig parameters to traverse.  Set once during
+  /// construction.
+  unsigned numOrigParams;
+
+  /// The index of the current orig parameter.
+  /// Incremented during advance().
+  unsigned origParamIndex = 0;
+
+  /// The (start) index of the current subst parameters.
+  /// Incremented during advance().
+  unsigned substParamIndex = 0;
+
+  /// The number of subst parameters corresponding to the current
+  /// subst parameter.
+  unsigned numSubstParamsForOrigParam;
+
+  /// Whether the orig function type is opaque, i.e. does not permit us to
+  /// call getNumFunctionParams() and similar accessors.  Set once during
+  /// construction.
+  bool origFunctionTypeIsOpaque;
+
+  /// Whether the current orig parameter is a pack expansion.
+  bool origParamIsExpansion;
+
+  /// The abstraction pattern of the current orig parameter.
+  /// If it is a pack expansion, this is the expansion type, not the
+  /// pattern type.
+  AbstractionPattern origParamType = AbstractionPattern::getInvalid();
+
+  /// Load the informaton for the current orig parameter into the
+  /// fields above for it.
+  void loadParameter() {
+    origParamType = origFunctionType.getFunctionParamType(origParamIndex);
+    origParamIsExpansion = origParamType.isPackExpansion();
+    numSubstParamsForOrigParam =
+      (origParamIsExpansion
+         ? origParamType.getNumPackExpandedComponents()
+         : 1);
+  }
+
+public:
+  FunctionParamGenerator(AbstractionPattern origFunctionType,
+                         AnyFunctionType::CanParamArrayRef substParams,
+                         bool ignoreFinalParam);
+
+  /// Is the traversal finished?  If so, none of the getters below
+  /// are allowed to be called.
+  bool isFinished() const {
+    return origParamIndex == numOrigParams;
+  }
+
+  /// Advance to the next orig parameter.
+  void advance() {
+    assert(!isFinished());
+    origParamIndex++;
+    substParamIndex += numSubstParamsForOrigParam;
+    if (!isFinished()) loadParameter();
+  }
+
+  /// Return the index of the current orig parameter.
+  unsigned getOrigIndex() const {
+    assert(!isFinished());
+    return origParamIndex;
+  }
+
+  /// Return the index of the (first) subst parameter corresponding
+  /// to the current orig parameter.
+  unsigned getSubstIndex() const {
+    assert(!isFinished());
+    return origParamIndex;
+  }
+
+  /// Return the parameter flags for the current orig parameter.
+  ParameterTypeFlags getOrigFlags() const {
+    assert(!isFinished());
+    return (origFunctionTypeIsOpaque
+              ? allSubstParams[substParamIndex].getParameterFlags()
+              : origFunctionType.getFunctionParamFlags(origParamIndex));
+  }
+
+  /// Return the type of the current orig parameter.
+  const AbstractionPattern &getOrigType() const {
+    assert(!isFinished());
+    return origParamType;
+  }
+
+  /// Return whether the current orig parameter type is a pack expansion.
+  bool isPackExpansion() const {
+    assert(!isFinished());
+    return origParamIsExpansion;
+  }
+
+  /// Return the substituted parameters corresponding to the current
+  /// orig parameter type.  If the current orig parameter is not a
+  /// pack expansion, this will have exactly one element.
+  AnyFunctionType::CanParamArrayRef getSubstParams() const {
+    assert(!isFinished());
+    return allSubstParams.slice(substParamIndex, numSubstParamsForOrigParam);
+  }
+
+  /// Call this to finalize the traversal and assert that it was done
+  /// properly.
+  void finish() {
+    assert(isFinished() && "didn't finish the traversal");
+    assert(substParamIndex == allSubstParams.size() &&
+           "didn't exhaust subst parameters; possible missing subs on "
+           "orig function type");
+  }
+};
+
+} // end namespace Lowering
+} // end namespace swift
+
+#endif

lib/SIL/IR/AbstractionPattern.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/CanTypeVisitor.h"
 #include "swift/SIL/TypeLowering.h"
+#include "swift/SIL/AbstractionPatternGenerators.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
@@ -1215,42 +1216,47 @@ forEachFunctionParam(AnyFunctionType::CanParamArrayRef substParams,
                                  AbstractionPattern origExpansionType,
                         AnyFunctionType::CanParamArrayRef substParams)>
              handleExpansion) const {
-  // Honor ignoreFinalParam for the substituted parameters on all paths.
-  if (ignoreFinalParam) substParams = substParams.drop_back();
-
-  // If we don't have a function type, use the substituted type.
-  if (isTypeParameterOrOpaqueArchetype() ||
-      getKind() == Kind::OpaqueFunction ||
-      getKind() == Kind::OpaqueDerivativeFunction) {
-    for (auto substParamIndex : indices(substParams)) {
-      handleScalar(substParamIndex, substParamIndex,
-                   substParams[substParamIndex].getParameterFlags(),
-                   AbstractionPattern::getOpaque(),
-                   substParams[substParamIndex]);
+  FunctionParamGenerator generator(*this, substParams, ignoreFinalParam);
+
+  for (; !generator.isFinished(); generator.advance()) {
+    if (generator.isPackExpansion()) {
+      handleExpansion(generator.getOrigIndex(),
+                      generator.getSubstIndex(),
+                      generator.getOrigFlags(),
+                      generator.getOrigType(),
+                      generator.getSubstParams());
+    } else {
+      handleScalar(generator.getOrigIndex(),
+                   generator.getSubstIndex(),
+                   generator.getOrigFlags(),
+                   generator.getOrigType(),
+                   generator.getSubstParams()[0]);
     }
-    return;
   }
+  generator.finish();
+}
 
-  size_t numOrigParams = getNumFunctionParams();
-  if (ignoreFinalParam) numOrigParams--;
+FunctionParamGenerator::FunctionParamGenerator(
+                              AbstractionPattern origFunctionType,
+                              AnyFunctionType::CanParamArrayRef substParams,
+                              bool ignoreFinalParam)
+    : origFunctionType(origFunctionType), allSubstParams(substParams) {
+  origFunctionTypeIsOpaque =
+    (origFunctionType.isTypeParameterOrOpaqueArchetype() ||
+     origFunctionType.isOpaqueFunctionOrOpaqueDerivativeFunction());
 
-  size_t substParamIndex = 0;
-  for (auto origParamIndex : range(numOrigParams)) {
-    auto origParamType = getFunctionParamType(origParamIndex);
-    if (origParamType.isPackExpansion()) {
-      unsigned numComponents = origParamType.getNumPackExpandedComponents();
-      handleExpansion(origParamIndex, substParamIndex,
-                      getFunctionParamFlags(origParamIndex), origParamType,
-                      substParams.slice(substParamIndex, numComponents));
-      substParamIndex += numComponents;
-    } else {
-      handleScalar(origParamIndex, substParamIndex,
-                   getFunctionParamFlags(origParamIndex), origParamType,
-                   substParams[substParamIndex]);
-      substParamIndex++;
-    }
+  if (origFunctionTypeIsOpaque) {
+    numOrigParams = allSubstParams.size();
+  } else {
+    numOrigParams = origFunctionType.getNumFunctionParams();
+  }
+
+  if (ignoreFinalParam) {
+    allSubstParams = allSubstParams.drop_back();
+    numOrigParams--;
   }
-  assert(substParamIndex == substParams.size());
+
+  if (!isFinished()) loadParameter();
 }
 
 static CanType getOptionalObjectType(CanType type) {