Preliminary constraint solver support for variadic generics

include/swift/AST/Decl.h

@@ -8399,6 +8399,10 @@ ParameterList *getParameterList(ValueDecl *source);
 /// there is none.
 ParameterList *getParameterList(DeclContext *source);
 
+/// Retrieve parameter declaration from the given source at given index, or
+/// nullptr if the source does not have a parameter list.
+const ParamDecl *getParameterAt(ConcreteDeclRef declRef, unsigned index);
+
 /// Retrieve parameter declaration from the given source at given index, or
 /// nullptr if the source does not have a parameter list.
 const ParamDecl *getParameterAt(const ValueDecl *source, unsigned index);

include/swift/AST/Expr.h

@@ -359,11 +359,6 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     IsPlaceholder : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(PackExpr, Expr, 32,
-    : NumPadBits,
-    NumElements : 32
-  );
-
   SWIFT_INLINE_BITFIELD_FULL(TypeJoinExpr, Expr, 32,
     : NumPadBits,
     NumElements : 32
@@ -5908,55 +5903,6 @@ class OneWayExpr : public Expr {
   }
 };
 
-/// An expression node that aggregates a set of heterogeneous arguments into a
-/// parameter pack suitable for passing off to a variadic generic function
-/// argument.
-///
-/// There is no user-visible way to spell a pack expression, they are always
-/// implicitly created at applies. As such, any appearance of pack types outside
-/// of applies are illegal.
-class PackExpr final : public Expr,
-    private llvm::TrailingObjects<PackExpr, Expr *> {
-  friend TrailingObjects;
-
-  size_t numTrailingObjects() const {
-    return getNumElements();
-  }
-
-  PackExpr(ArrayRef<Expr *> SubExprs, Type Ty);
-
-public:
-  /// Create a pack.
-  static PackExpr *create(ASTContext &ctx, ArrayRef<Expr *> SubExprs, Type Ty);
-
-  /// Create an empty pack.
-  static PackExpr *createEmpty(ASTContext &ctx);
-
-  SourceLoc getLoc() const { return SourceLoc(); }
-  SourceRange getSourceRange() const { return SourceRange(); }
-
-  /// Retrieve the elements of this pack.
-  MutableArrayRef<Expr *> getElements() {
-    return { getTrailingObjects<Expr *>(), getNumElements() };
-  }
-
-  /// Retrieve the elements of this pack.
-  ArrayRef<Expr *> getElements() const {
-    return { getTrailingObjects<Expr *>(), getNumElements() };
-  }
-
-  unsigned getNumElements() const { return Bits.PackExpr.NumElements; }
-
-  Expr *getElement(unsigned i) const {
-    return getElements()[i];
-  }
-  void setElement(unsigned i, Expr *e) {
-    getElements()[i] = e;
-  }
-
-  static bool classof(const Expr *E) { return E->getKind() == ExprKind::Pack; }
-};
-
 class TypeJoinExpr final : public Expr,
                            private llvm::TrailingObjects<TypeJoinExpr, Expr *> {
   friend TrailingObjects;

include/swift/AST/ExprNodes.def

@@ -206,7 +206,6 @@ EXPR(KeyPath, Expr)
 UNCHECKED_EXPR(KeyPathDot, Expr)
 UNCHECKED_EXPR(OneWay, Expr)
 EXPR(Tap, Expr)
-EXPR(Pack, Expr)
 UNCHECKED_EXPR(TypeJoin, Expr)
 LAST_EXPR(TypeJoin)
 

include/swift/AST/PackExpansionMatcher.h

@@ -0,0 +1,90 @@
+//===--- PackExpansionMatcher.h - Matching pack expansions ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for structural matching of sequences of types containing pack
+// expansions.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_PACK_EXPANSION_MATCHER_H
+#define SWIFT_AST_PACK_EXPANSION_MATCHER_H
+
+#include "swift/AST/Type.h"
+#include "swift/AST/Types.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+
+namespace swift {
+
+class ASTContext;
+
+/// The result of a match. If one of lhs or rhs is a pack expansion type,
+/// the other one is a pack type.
+struct MatchedPair {
+  Type lhs;
+  Type rhs;
+
+  // An index into the original left-hand side.
+  unsigned idx;
+
+  MatchedPair(Type lhs, Type rhs, unsigned idx)
+    : lhs(lhs), rhs(rhs), idx(idx) {}
+};
+
+/// Performs a structural match of two lists of tuple elements. The invariant
+/// is that a pack expansion type must not be followed by an unlabeled
+/// element, that is, it is either the last element or the next element has
+/// a label.
+///
+/// In this manner, an element with a pack expansion type "absorbs" all
+/// unlabeled elements up to the next label. An element with any other type
+/// matches exactly one element on the other side.
+class TuplePackMatcher {
+  ArrayRef<TupleTypeElt> lhsElts;
+  ArrayRef<TupleTypeElt> rhsElts;
+
+  ASTContext &ctx;
+
+public:
+  SmallVector<MatchedPair, 4> pairs;
+
+  TuplePackMatcher(TupleType *lhsTuple, TupleType *rhsTuple);
+
+  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

include/swift/AST/ParameterList.h

@@ -24,6 +24,8 @@
 
 namespace swift {
 
+class SubstitutionMap;
+
 /// This describes a list of parameters.  Each parameter descriptor is tail
 /// allocated onto this list.
 class alignas(ParamDecl *) ParameterList final :
@@ -134,6 +136,8 @@ class alignas(ParamDecl *) ParameterList final :
   /// based on the interface types of the parameters in this list.
   void getParams(SmallVectorImpl<AnyFunctionType::Param> &params) const;
 
+  unsigned getOrigParamIndex(SubstitutionMap subMap, unsigned substIndex) const;
+
   /// Return the full source range of this parameter.
   SourceRange getSourceRange() const;
   SourceLoc getStartLoc() const { return getSourceRange().Start; }

include/swift/AST/Types.h

@@ -384,9 +384,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
     NumProtocols : 16
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 5+32,
+  SWIFT_INLINE_BITFIELD_FULL(TypeVariableType, TypeBase, 6+32,
     /// Type variable options.
-    Options : 5,
+    Options : 6,
     : NumPadBits,
     /// The unique number assigned to this type variable.
     ID : 32
@@ -2323,6 +2323,10 @@ class TupleType final : public TypeBase, public llvm::FoldingSetNode,
   static void Profile(llvm::FoldingSetNodeID &ID, 
                       ArrayRef<TupleTypeElt> Elements);
 
+  bool containsPackExpansionType() const;
+
+  TupleType *flattenPackTypes();
+
 private:
   TupleType(ArrayRef<TupleTypeElt> elements, const ASTContext *CanCtx,
             RecursiveTypeProperties properties)
@@ -3357,6 +3361,10 @@ class AnyFunctionType : public TypeBase {
   /// replaced.
   AnyFunctionType *withExtInfo(ExtInfo info) const;
 
+  static bool containsPackExpansionType(ArrayRef<Param> params);
+
+  AnyFunctionType *flattenPackTypes();
+
   static void printParams(ArrayRef<Param> Params, raw_ostream &OS,
                           const PrintOptions &PO = PrintOptions());
   static void printParams(ArrayRef<Param> Params, ASTPrinter &Printer,
@@ -6410,6 +6418,10 @@ class PackType final : public TypeBase, public llvm::FoldingSetNode,
     return getTrailingObjects<Type>()[index];
   }
 
+  bool containsPackExpansionType() const;
+
+  PackType *flattenPackTypes();
+
 public:
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Profile(ID, getElementTypes());
@@ -6480,6 +6492,8 @@ class PackExpansionType : public TypeBase, public llvm::FoldingSetNode {
   /// Retrieves the count type of this pack expansion.
   Type getCountType() const { return countType; }
 
+  PackExpansionType *expand();
+
 public:
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getPatternType(), getCountType());

include/swift/Sema/ConstraintSystem.h

@@ -330,6 +330,9 @@ enum TypeVariableOptions {
   /// Whether a more specific deduction for this type variable implies a
   /// better solution to the constraint system.
   TVO_PrefersSubtypeBinding = 0x10,
+
+  /// Whether the type variable can be bound to a pack type or not.
+  TVO_CanBindToPack = 0x20,
 };
 
 /// The implementation object for a type variable used within the
@@ -387,18 +390,21 @@ class TypeVariableType::Implementation {
            && "Truncation");
   }
 
-  /// Whether this type variable can bind to an lvalue type.
+  /// Whether this type variable can bind to an LValueType.
   bool canBindToLValue() const { return getRawOptions() & TVO_CanBindToLValue; }
 
-  /// Whether this type variable can bind to an inout type.
+  /// Whether this type variable can bind to an InOutType.
   bool canBindToInOut() const { return getRawOptions() & TVO_CanBindToInOut; }
 
-  /// Whether this type variable can bind to an inout type.
+  /// Whether this type variable can bind to a noescape FunctionType.
   bool canBindToNoEscape() const { return getRawOptions() & TVO_CanBindToNoEscape; }
 
-  /// Whether this type variable can bind to a hole.
+  /// Whether this type variable can bind to a PlaceholderType.
   bool canBindToHole() const { return getRawOptions() & TVO_CanBindToHole; }
 
+  /// Whether this type variable can bind to a PackType.
+  bool canBindToPack() const { return getRawOptions() & TVO_CanBindToPack; }
+
   /// Whether this type variable prefers a subtype binding over a supertype
   /// binding.
   bool prefersSubtypeBinding() const {
@@ -638,6 +644,7 @@ class TypeVariableType::Implementation {
     ENTRY(TVO_CanBindToNoEscape, "noescape");
     ENTRY(TVO_CanBindToHole, "hole");
     ENTRY(TVO_PrefersSubtypeBinding, "");
+    ENTRY(TVO_CanBindToPack, "pack");
     }
   #undef ENTRY
   }
@@ -5197,15 +5204,6 @@ class ConstraintSystem {
                                   ConstraintKind kind, TypeMatchOptions flags,
                                   ConstraintLocatorBuilder locator);
 
-  /// Subroutine of \c matchTypes(), which matches a scalar type to
-  /// a tuple type.
-  ///
-  /// \returns the result of performing the scalar-to-tuple conversion.
-  TypeMatchResult matchScalarToTupleTypes(Type type1, TupleType *tuple2,
-                                          ConstraintKind kind,
-                                          TypeMatchOptions flags,
-                                          ConstraintLocatorBuilder locator);
-
   /// Subroutine of \c matchTypes(), which matches up two function
   /// types.
   TypeMatchResult matchFunctionTypes(FunctionType *func1, FunctionType *func2,
@@ -6083,27 +6081,19 @@ class HandlePlaceholderType {
 /// Compute the shuffle required to map from a given tuple type to
 /// another tuple type.
 ///
-/// \param fromTuple The tuple type we're converting from, as represented by its
-/// TupleTypeElt members.
+/// \param fromTuple The tuple type we're converting from.
 ///
-/// \param toTuple The tuple type we're converting to, as represented by its
-/// TupleTypeElt members.
+/// \param toTuple The tuple type we're converting to.
 ///
 /// \param sources Will be populated with information about the source of each
 /// of the elements for the result tuple. The indices into this array are the
 /// indices of the tuple type we're converting to, while the values are
 /// an index into the source tuple.
 ///
 /// \returns true if no tuple conversion is possible, false otherwise.
-bool computeTupleShuffle(ArrayRef<TupleTypeElt> fromTuple,
-                         ArrayRef<TupleTypeElt> toTuple,
+bool computeTupleShuffle(TupleType *fromTuple,
+                         TupleType *toTuple,
                          SmallVectorImpl<unsigned> &sources);
-static inline bool computeTupleShuffle(TupleType *fromTuple,
-                                       TupleType *toTuple,
-                                       SmallVectorImpl<unsigned> &sources){
-  return computeTupleShuffle(fromTuple->getElements(), toTuple->getElements(),
-                             sources);
-}
 
 /// Class used as the base for listeners to the \c matchCallArguments process.
 ///

lib/AST/ASTContext.cpp

@@ -3135,6 +3135,15 @@ TupleType *TupleType::get(ArrayRef<TupleTypeElt> Fields, const ASTContext &C) {
     properties |= eltTy->getRecursiveProperties();
   }
 
+  // Enforce an invariant.
+  for (unsigned i = 0, e = Fields.size(); i < e; ++i) {
+    if (Fields[i].getType()->is<PackExpansionType>()) {
+      assert(i == e - 1 || Fields[i + 1].hasName() &&
+             "Tuple element with pack expansion type cannot be followed "
+             "by an unlabeled element");
+    }
+  }
+
   auto arena = getArena(properties);
 
   void *InsertPos = nullptr;
@@ -3173,8 +3182,14 @@ PackExpansionType::PackExpansionType(Type patternType, Type countType,
                                      const ASTContext *canCtx)
   : TypeBase(TypeKind::PackExpansion, canCtx, properties),
     patternType(patternType), countType(countType) {
-  assert(countType->is<TypeVariableType>() ||
+
+  // TODO: it would be nice if the solver didn't stick PlaceholderTypes and
+  // UnresolvedTypes in here.
+  assert(countType->is<PackType>() ||
+         countType->is<TypeVariableType>() ||
          countType->is<PackArchetypeType>() ||
+         countType->is<PlaceholderType>() ||
+         countType->is<UnresolvedType>() ||
          countType->castTo<GenericTypeParamType>()->isParameterPack());
 }