AST: Introduce ParamPackMatcher, for structural matching of function types

Author: slavapestov

include/swift/AST/PackExpansionMatcher.h

@@ -62,6 +62,29 @@ class TuplePackMatcher {
   bool match();
 };
 
+/// Performs a structural match of two lists of (unlabeled) function
+/// parameters.
+///
+/// The invariant is that each list must only contain at most one pack
+/// expansion type. After collecting a common prefix and suffix, the
+/// pack expansion on either side asborbs the remaining elements on the
+/// other side.
+class ParamPackMatcher {
+  ArrayRef<AnyFunctionType::Param> lhsParams;
+  ArrayRef<AnyFunctionType::Param> rhsParams;
+
+  ASTContext &ctx;
+
+public:
+  SmallVector<MatchedPair, 4> pairs;
+
+  ParamPackMatcher(ArrayRef<AnyFunctionType::Param> lhsParams,
+                   ArrayRef<AnyFunctionType::Param> rhsParams,
+                   ASTContext &ctx);
+
+  bool match();
+};
+
 } // end namespace swift
 
 #endif // SWIFT_AST_TYPE_MATCHER_H

lib/AST/PackExpansionMatcher.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
 #include "llvm/ADT/SmallVector.h"
+#include <algorithm>
 
 using namespace swift;
 
@@ -104,4 +105,105 @@ bool TuplePackMatcher::match() {
   }
 
   return false;
+}
+
+ParamPackMatcher::ParamPackMatcher(
+    ArrayRef<AnyFunctionType::Param> lhsParams,
+    ArrayRef<AnyFunctionType::Param> rhsParams,
+    ASTContext &ctx)
+  : lhsParams(lhsParams), rhsParams(rhsParams), ctx(ctx) {}
+
+bool ParamPackMatcher::match() {
+  unsigned minLength = std::min(lhsParams.size(), rhsParams.size());
+
+  // Consume the longest possible prefix where neither type in
+  // the pair is a pack expansion type.
+  unsigned prefixLength = 0;
+  for (unsigned i = 0; i < minLength; ++i) {
+    auto lhsParam = lhsParams[i];
+    auto rhsParam = rhsParams[i];
+
+    // FIXME: Check flags
+
+    auto lhsType = lhsParam.getPlainType();
+    auto rhsType = rhsParam.getPlainType();
+
+    if (lhsType->is<PackExpansionType>() ||
+        rhsType->is<PackExpansionType>()) {
+      break;
+    }
+
+    // FIXME: Check flags
+
+    pairs.emplace_back(lhsType, rhsType, i);
+    ++prefixLength;
+  }
+
+  // Consume the longest possible suffix where neither type in
+  // the pair is a pack expansion type.
+  unsigned suffixLength = 0;
+  for (unsigned i = 0; i < minLength - prefixLength; ++i) {
+    auto lhsParam = lhsParams[lhsParams.size() - i - 1];
+    auto rhsParam = rhsParams[rhsParams.size() - i - 1];
+
+    // FIXME: Check flags
+
+    auto lhsType = lhsParam.getPlainType();
+    auto rhsType = rhsParam.getPlainType();
+
+    if (lhsType->is<PackExpansionType>() ||
+        rhsType->is<PackExpansionType>()) {
+      break;
+    }
+
+    pairs.emplace_back(lhsType, rhsType, i);
+    ++suffixLength;
+  }
+
+  assert(prefixLength + suffixLength <= lhsParams.size());
+  assert(prefixLength + suffixLength <= rhsParams.size());
+
+  // Drop the consumed prefix and suffix from each list of types.
+  lhsParams = lhsParams.drop_front(prefixLength).drop_back(suffixLength);
+  rhsParams = rhsParams.drop_front(prefixLength).drop_back(suffixLength);
+
+  // If the left hand side is a single pack expansion type, bind it
+  // to what remains of the right hand side.
+  if (lhsParams.size() == 1 &&
+      lhsParams[0].getPlainType()->is<PackExpansionType>()) {
+    SmallVector<Type, 2> rhsTypes;
+    for (auto rhsParam : rhsParams) {
+      // FIXME: Check rhs flags
+      rhsTypes.push_back(rhsParam.getPlainType());
+    }
+    auto rhs = PackType::get(ctx, rhsTypes);
+
+    // FIXME: Check lhs flags
+    pairs.emplace_back(lhsParams[0].getPlainType(), rhs, prefixLength);
+    return false;
+  }
+
+  // If the right hand side is a single pack expansion type, bind it
+  // to what remains of the left hand side.
+  if (rhsParams.size() == 1 &&
+      rhsParams[0].getPlainType()->is<PackExpansionType>()) {
+    SmallVector<Type, 2> lhsTypes;
+    for (auto lhsParam : lhsParams) {
+      // FIXME: Check lhs flags
+      lhsTypes.push_back(lhsParam.getPlainType());
+    }
+    auto lhs = PackType::get(ctx, lhsTypes);
+
+    // FIXME: Check rhs flags
+    pairs.emplace_back(lhs, rhsParams[0].getPlainType(), prefixLength);
+    return false;
+  }
+
+  // Otherwise, all remaining possibilities are invalid:
+  // - Neither side has any pack expansions, and they have different lengths.
+  // - One side has a pack expansion but the other side is too short, eg
+  //   {Int, T..., Float} vs {Int}.
+  // - The prefix and suffix are mismatched, so we're left with something
+  //   like {T..., Int} vs {Float, U...}.
+  return true;
 }