Implement Pack Locators

Author: CodaFi

include/swift/Sema/ConstraintLocator.h

@@ -641,6 +641,32 @@ class LocatorPathElt::NamedTupleElement final
   }
 };
 
+class LocatorPathElt::PackType : public StoredPointerElement<TypeBase> {
+public:
+  PackType(Type type)
+      : StoredPointerElement(PathElementKind::PackType, type.getPointer()) {
+    assert(type->getDesugaredType()->is<swift::PackType>());
+  }
+
+  Type getType() const { return getStoredPointer(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == PathElementKind::PackType;
+  }
+};
+
+class LocatorPathElt::PackElement final : public StoredIntegerElement<1> {
+public:
+  PackElement(unsigned index)
+      : StoredIntegerElement(ConstraintLocator::PackElement, index) {}
+
+  unsigned getIndex() const { return getValue<0>(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::PackElement;
+  }
+};
+
 class LocatorPathElt::KeyPathComponent final : public StoredIntegerElement<1> {
 public:
   KeyPathComponent(unsigned index)
@@ -758,6 +784,10 @@ class LocatorPathElt::GenericParameter final : public StoredPointerElement<Gener
   GenericTypeParamType *getType() const {
     return getStoredPointer();
   }
+    
+  bool isTypeSequence() const {
+    return getType()->isTypeSequence();
+  }
 
   static bool classof(const LocatorPathElt *elt) {
     return elt->getKind() == PathElementKind::GenericParameter;

include/swift/Sema/ConstraintLocatorPathElts.def

@@ -183,6 +183,12 @@ ABSTRACT_LOCATOR_PATH_ELT(AnyTupleElement)
   /// A tuple element referenced by name.
   CUSTOM_LOCATOR_PATH_ELT(NamedTupleElement)
 
+/// Pack types <T, U, V, ...>
+CUSTOM_LOCATOR_PATH_ELT(PackType)
+
+/// An element of a pack type - the T in <T, U, V, ...>
+CUSTOM_LOCATOR_PATH_ELT(PackElement)
+
 /// An unresolved member.
 SIMPLE_LOCATOR_PATH_ELT(UnresolvedMember)
 

include/swift/Sema/ConstraintSystem.h

@@ -4071,6 +4071,8 @@ class ConstraintSystem {
   /// parameter types and dependent member types with fresh type variables.
   ///
   /// \param type The type to open.
+  /// \param replacements The mapping from generic type parameters to their
+  ///                     corresponding opened type variables.
   ///
   /// \returns The opened type, or \c type if there are no archetypes in it.
   Type openType(Type type, OpenedTypeMap &replacements);
@@ -4484,6 +4486,11 @@ class ConstraintSystem {
                       SmallVectorImpl<RestrictionOrFix> &conversionsOrFixes,
                       ConstraintLocatorBuilder locator);
 
+  TypeMatchResult
+  matchPackTypes(PackType *pack1, PackType *pack2,
+                 ConstraintKind kind, TypeMatchOptions flags,
+                 ConstraintLocatorBuilder locator);
+
   /// Subroutine of \c matchTypes(), which matches up two tuple types.
   ///
   /// \returns the result of performing the tuple-to-tuple conversion.

lib/Sema/ConstraintLocator.cpp

@@ -94,6 +94,8 @@ unsigned LocatorPathElt::getNewSummaryFlags() const {
   case ConstraintLocator::ImplicitConversion:
   case ConstraintLocator::ImplicitDynamicMemberSubscript:
   case ConstraintLocator::ClosureBodyElement:
+  case ConstraintLocator::PackType:
+  case ConstraintLocator::PackElement:
     return 0;
 
   case ConstraintLocator::FunctionArgument:
@@ -561,11 +563,22 @@ void ConstraintLocator::dump(SourceManager *sm, raw_ostream &out) const {
       out << "implicit dynamic member subscript";
       break;
 
-    case ConstraintLocator::ImplicitConversion:
+    case ConstraintLocator::ImplicitConversion: {
       auto convElt = elt.castTo<LocatorPathElt::ImplicitConversion>();
       out << "implicit conversion " << getName(convElt.getConversionKind());
       break;
     }
+
+    case ConstraintLocator::PackType:
+      out << "pack type";
+      break;
+
+    case PackElement: {
+      auto packElt = elt.castTo<LocatorPathElt::PackElement>();
+      out << "pack element #" << llvm::utostr(packElt.getIndex());
+      break;
+    }
+    }
   }
   out << ']';
 }