Merge pull request #61537 from hborla/variadic-generics-terminology

[AST] Use consistent variadic generics terminology.

Author: slavapestov

include/swift/AST/Decl.h

@@ -505,7 +505,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 
     Depth : 16,
     Index : 16,
-    TypeSequence : 1,
+    ParameterPack : 1,
 
     /// Whether this generic parameter represents an opaque type.
     IsOpaqueType : 1
@@ -3179,7 +3179,7 @@ class GenericTypeParamDecl final :
   /// \param name The name of the generic parameter.
   /// \param nameLoc The location of the name.
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
-                       bool isTypeSequence, unsigned depth, unsigned index,
+                       bool isParameterPack, unsigned depth, unsigned index,
                        bool isOpaqueType, TypeRepr *typeRepr);
 
 public:
@@ -3192,15 +3192,15 @@ class GenericTypeParamDecl final :
   /// \param name The name of the generic parameter.
   /// \param nameLoc The location of the name.
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
-                       bool isTypeSequence, unsigned depth, unsigned index)
-      : GenericTypeParamDecl(dc, name, nameLoc, isTypeSequence, depth, index,
+                       bool isParameterPack, unsigned depth, unsigned index)
+      : GenericTypeParamDecl(dc, name, nameLoc, isParameterPack, depth, index,
                              false, nullptr) { }
 
   static const unsigned InvalidDepth = 0xFFFF;
 
   static GenericTypeParamDecl *
   create(DeclContext *dc, Identifier name, SourceLoc nameLoc,
-         bool isTypeSequence, unsigned depth, unsigned index,
+         bool isParameterPack, unsigned depth, unsigned index,
          bool isOpaqueType, TypeRepr *typeRepr);
 
   /// The depth of this generic type parameter, i.e., the number of outer
@@ -3224,13 +3224,13 @@ class GenericTypeParamDecl final :
   }
 
   /// Returns \c true if this generic type parameter is declared as a type
-  /// sequence.
+  /// parameter pack.
   ///
   /// \code
-  /// func foo<@_typeSequence T>(_ : T...) { }
-  /// struct Foo<@_typeSequence T> { }
+  /// func foo<T...>(_ : T...) { }
+  /// struct Foo<T...> { }
   /// \endcode
-  bool isTypeSequence() const { return Bits.GenericTypeParamDecl.TypeSequence; }
+  bool isParameterPack() const { return Bits.GenericTypeParamDecl.ParameterPack; }
 
   /// Determine whether this generic parameter represents an opaque type.
   ///
@@ -8238,7 +8238,7 @@ inline bool Decl::isSyntacticallyOverridable() const {
 }
 
 inline GenericParamKey::GenericParamKey(const GenericTypeParamDecl *d)
-    : TypeSequence(d->isTypeSequence()), Depth(d->getDepth()),
+    : ParameterPack(d->isParameterPack()), Depth(d->getDepth()),
       Index(d->getIndex()) {}
 
 inline const GenericContext *Decl::getAsGenericContext() const {

include/swift/AST/Expr.h

@@ -3399,18 +3399,6 @@ class BridgeToObjCExpr : public ImplicitConversionExpr {
   }
 };
 
-/// ReifyPackExpr - Drop the pack structure and reify it either as a tuple or
-/// single value.
-class ReifyPackExpr : public ImplicitConversionExpr {
-public:
-  ReifyPackExpr(Expr *subExpr, Type type)
-    : ImplicitConversionExpr(ExprKind::ReifyPack, subExpr, type) {}
-
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::ReifyPack;
-  }
-};
-
 /// UnresolvedSpecializeExpr - Represents an explicit specialization using
 /// a type parameter list (e.g. "Vector<Int>") that has not been resolved.
 class UnresolvedSpecializeExpr final : public Expr,
@@ -5926,8 +5914,7 @@ class OneWayExpr : public Expr {
 ///
 /// 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. In general, packs appearing in such positions should
-/// have a \c ReifyPackExpr to convert them to a user-available AST type.
+/// of applies are illegal.
 class PackExpr final : public Expr,
     private llvm::TrailingObjects<PackExpr, Expr *> {
   friend TrailingObjects;

include/swift/AST/ExprNodes.def

@@ -184,8 +184,7 @@ ABSTRACT_EXPR(ImplicitConversion, Expr)
   EXPR(DifferentiableFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearFunctionExtractOriginal, ImplicitConversionExpr)
   EXPR(LinearToDifferentiableFunction, ImplicitConversionExpr)
-  EXPR(ReifyPack, ImplicitConversionExpr)
-  EXPR_RANGE(ImplicitConversion, Load, ReifyPack)
+  EXPR_RANGE(ImplicitConversion, Load, LinearToDifferentiableFunction)
 ABSTRACT_EXPR(ExplicitCast, Expr)
   ABSTRACT_EXPR(CheckedCast, ExplicitCastExpr)
     EXPR(ForcedCheckedCast, CheckedCastExpr)

include/swift/AST/GenericParamKey.h

@@ -24,18 +24,19 @@ class GenericTypeParamType;
 /// A fully-abstracted generic type parameter key, maintaining only the depth
 /// and index of the generic parameter.
 struct GenericParamKey {
-  unsigned TypeSequence : 1;
+  unsigned ParameterPack : 1;
   unsigned Depth : 15;
   unsigned Index : 16;
 
-  GenericParamKey(bool isTypeSequence, unsigned depth, unsigned index)
-      : TypeSequence(isTypeSequence), Depth(depth), Index(index) {}
+  GenericParamKey(bool isParameterPack, unsigned depth, unsigned index)
+      : ParameterPack(isParameterPack), Depth(depth), Index(index) {}
 
   GenericParamKey(const GenericTypeParamDecl *d);
   GenericParamKey(const GenericTypeParamType *d);
 
   friend bool operator==(GenericParamKey lhs, GenericParamKey rhs) {
-    return lhs.TypeSequence == rhs.TypeSequence && lhs.Depth == rhs.Depth &&
+    return lhs.ParameterPack == rhs.ParameterPack &&
+           lhs.Depth == rhs.Depth &&
            lhs.Index == rhs.Index;
   }
 
@@ -110,11 +111,12 @@ struct DenseMapInfo<swift::GenericParamKey> {
 
   static inline unsigned getHashValue(swift::GenericParamKey k) {
     return DenseMapInfo<unsigned>::getHashValue(
-        k.Depth << 16 | k.Index | ((k.TypeSequence ? 1 : 0) << 30));
+        k.Depth << 16 | k.Index | ((k.ParameterPack ? 1 : 0) << 30));
   }
   static bool isEqual(swift::GenericParamKey a,
                       swift::GenericParamKey b) {
-    return a.TypeSequence == b.TypeSequence && a.Depth == b.Depth &&
+    return a.ParameterPack == b.ParameterPack &&
+           a.Depth == b.Depth &&
            a.Index == b.Index;
   }
 };

include/swift/AST/TypeNodes.def

@@ -148,8 +148,8 @@ ABSTRACT_TYPE(Substitutable, Type)
     ALWAYS_CANONICAL_TYPE(PrimaryArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpenedArchetype, ArchetypeType)
-    ALWAYS_CANONICAL_TYPE(SequenceArchetype, ArchetypeType)
-    TYPE_RANGE(Archetype, PrimaryArchetype, SequenceArchetype)
+    ALWAYS_CANONICAL_TYPE(PackArchetype, ArchetypeType)
+    TYPE_RANGE(Archetype, PrimaryArchetype, PackArchetype)
   TYPE(GenericTypeParam, SubstitutableType)
   TYPE_RANGE(Substitutable, PrimaryArchetype, GenericTypeParam)
 TYPE(DependentMember, Type)

include/swift/AST/Types.h

@@ -126,7 +126,7 @@ class RecursiveTypeProperties {
 
     /// This type expression contains a context-dependent archetype, either a
     /// \c PrimaryArchetypeType, \c OpenedArchetypeType, or
-    /// \c SequenceArchetype.
+    /// \c PackArchetype.
     HasArchetype         = 0x02,
 
     /// This type expression contains a GenericTypeParamType.
@@ -161,8 +161,8 @@ class RecursiveTypeProperties {
     HasPlaceholder       = 0x800,
 
     /// This type contains a generic type parameter that is declared as a
-    /// type sequence
-    HasTypeSequence = 0x1000,
+    /// parameter pack.
+    HasParameterPack = 0x1000,
 
     /// This type contains a parameterized existential type \c any P<T>.
     HasParameterizedExistential = 0x2000,
@@ -225,7 +225,7 @@ class RecursiveTypeProperties {
   /// Does a type with these properties structurally contain a placeholder?
   bool hasPlaceholder() const { return Bits & HasPlaceholder; }
 
-  bool hasTypeSequence() const { return Bits & HasTypeSequence; }
+  bool hasParameterPack() const { return Bits & HasParameterPack; }
 
   /// Does a type with these properties structurally contain a
   /// parameterized existential type?
@@ -624,8 +624,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
     return getRecursiveProperties().hasOpenedExistential();
   }
 
-  bool hasTypeSequence() const {
-    return getRecursiveProperties().hasTypeSequence();
+  bool hasParameterPack() const {
+    return getRecursiveProperties().hasParameterPack();
   }
 
   /// Determine whether the type involves a parameterized existential type.
@@ -655,10 +655,9 @@ class alignas(1 << TypeAlignInBits) TypeBase
   void getRootOpenedExistentials(
       SmallVectorImpl<OpenedArchetypeType *> &rootOpenedArchetypes) const;
 
-  /// Retrieve the set of type sequence generic parameters that occur
-  /// within this type.
-  void getTypeSequenceParameters(
-      SmallVectorImpl<Type> &rootTypeSequenceParams) const;
+  /// Retrieve the set of type parameter packs that occur within this type.
+  void getTypeParameterPacks(
+      SmallVectorImpl<Type> &rootParameterPacks) const;
 
   /// Replace opened archetypes with the given root with their most
   /// specific non-dependent upper bounds throughout this type.
@@ -689,12 +688,12 @@ class alignas(1 << TypeAlignInBits) TypeBase
   /// whether a type parameter exists at any position.
   bool isTypeParameter();
 
-  /// Determine whether this type is a type sequence parameter, which is
+  /// Determine whether this type is a type parameter pack, which is
   /// either a GenericTypeParamType or a DependentMemberType.
   ///
   /// Like \c isTypeParameter, this routine will return \c false for types that
   /// include type parameters in nested positions e.g. \c X<T...>.
-  bool isTypeSequenceParameter();
+  bool isParameterPack();
 
   /// Determine whether this type can dynamically be an optional type.
   ///
@@ -6002,15 +6001,11 @@ BEGIN_CAN_TYPE_WRAPPER(OpenedArchetypeType, ArchetypeType)
   }
 END_CAN_TYPE_WRAPPER(OpenedArchetypeType, ArchetypeType)
 
-/// An archetype that represents an opaque element of a type sequence in context.
-///
-/// \code
-/// struct Foo<@_typeSequence Ts> { var xs: @_typeSequence Ts }
-/// func foo<@_typeSequence T>(_ xs: T...) where T: P {  }
-/// \endcode
-class SequenceArchetypeType final
+/// An archetype that represents an opaque element of a type
+/// parameter pack in context.
+class PackArchetypeType final
     : public ArchetypeType,
-      private ArchetypeTrailingObjects<SequenceArchetypeType> {
+      private ArchetypeTrailingObjects<PackArchetypeType> {
   friend TrailingObjects;
   friend ArchetypeType;
 
@@ -6019,23 +6014,23 @@ class SequenceArchetypeType final
   ///
   /// The ConformsTo array will be minimized then copied into the ASTContext
   /// by this routine.
-  static CanTypeWrapper<SequenceArchetypeType>
+  static CanTypeWrapper<PackArchetypeType>
   get(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
       Type InterfaceType,
       SmallVectorImpl<ProtocolDecl *> &ConformsTo, Type Superclass,
       LayoutConstraint Layout);
 
   static bool classof(const TypeBase *T) {
-    return T->getKind() == TypeKind::SequenceArchetype;
+    return T->getKind() == TypeKind::PackArchetype;
   }
 
 private:
-  SequenceArchetypeType(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
-                        Type InterfaceType, ArrayRef<ProtocolDecl *> ConformsTo,
-                        Type Superclass, LayoutConstraint Layout);
+  PackArchetypeType(const ASTContext &Ctx, GenericEnvironment *GenericEnv,
+                    Type InterfaceType, ArrayRef<ProtocolDecl *> ConformsTo,
+                    Type Superclass, LayoutConstraint Layout);
 };
-BEGIN_CAN_TYPE_WRAPPER(SequenceArchetypeType, ArchetypeType)
-END_CAN_TYPE_WRAPPER(SequenceArchetypeType, ArchetypeType)
+BEGIN_CAN_TYPE_WRAPPER(PackArchetypeType, ArchetypeType)
+END_CAN_TYPE_WRAPPER(PackArchetypeType, ArchetypeType)
 
 template<typename Type>
 const Type *ArchetypeType::getSubclassTrailingObjects() const {
@@ -6048,7 +6043,7 @@ const Type *ArchetypeType::getSubclassTrailingObjects() const {
   if (auto openedTy = dyn_cast<OpenedArchetypeType>(this)) {
     return openedTy->getTrailingObjects<Type>();
   }
-  if (auto childTy = dyn_cast<SequenceArchetypeType>(this)) {
+  if (auto childTy = dyn_cast<PackArchetypeType>(this)) {
     return childTy->getTrailingObjects<Type>();
   }
   llvm_unreachable("unhandled ArchetypeType subclass?");
@@ -6067,7 +6062,7 @@ class GenericTypeParamType : public SubstitutableType {
 
 public:
   /// Retrieve a generic type parameter at the given depth and index.
-  static GenericTypeParamType *get(bool isTypeSequence, unsigned depth,
+  static GenericTypeParamType *get(bool isParameterPack, unsigned depth,
                                    unsigned index, const ASTContext &ctx);
 
   /// Retrieve the declaration of the generic type parameter, or null if
@@ -6103,14 +6098,13 @@ class GenericTypeParamType : public SubstitutableType {
   /// Here 'T' and 'U' have indexes 0 and 1, respectively. 'V' has index 0.
   unsigned getIndex() const;
 
-  /// Returns \c true if this generic type parameter is declared as a type
-  /// sequence.
+  /// Returns \c true if this type parameter is declared as a pack.
   ///
   /// \code
-  /// func foo<@_typeSequence T>(_ : T...) { }
-  /// struct Foo<@_typeSequence T> { }
-  /// \encode
-  bool isTypeSequence() const;
+  /// func foo<T...>() { }
+  /// struct Foo<T...> { }
+  /// \endcode
+  bool isParameterPack() const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const TypeBase *T) {
@@ -6125,18 +6119,18 @@ class GenericTypeParamType : public SubstitutableType {
     : SubstitutableType(TypeKind::GenericTypeParam, nullptr, props),
       ParamOrDepthIndex(param) { }
 
-  explicit GenericTypeParamType(bool isTypeSequence, unsigned depth,
+  explicit GenericTypeParamType(bool isParameterPack, unsigned depth,
                                 unsigned index, RecursiveTypeProperties props,
                                 const ASTContext &ctx)
       : SubstitutableType(TypeKind::GenericTypeParam, &ctx, props),
         ParamOrDepthIndex(depth << 16 | index |
-                          ((isTypeSequence ? 1 : 0) << 30)) {}
+                          ((isParameterPack ? 1 : 0) << 30)) {}
 };
 BEGIN_CAN_TYPE_WRAPPER(GenericTypeParamType, SubstitutableType)
-static CanGenericTypeParamType get(bool isTypeSequence, unsigned depth,
+static CanGenericTypeParamType get(bool isParameterPack, unsigned depth,
                                    unsigned index, const ASTContext &C) {
   return CanGenericTypeParamType(
-      GenericTypeParamType::get(isTypeSequence, depth, index, C));
+      GenericTypeParamType::get(isParameterPack, depth, index, C));
 }
 END_CAN_TYPE_WRAPPER(GenericTypeParamType, SubstitutableType)
 
@@ -6475,8 +6469,8 @@ class PackExpansionType : public TypeBase, public llvm::FoldingSetNode {
   /// a variadic generic parameter, but any variadic generic parameters
   /// appearing in the pattern type must have the same count as \p countType.
   ///
-  /// As for \p countType itself, it must be a type sequence generic parameter
-  /// type, or a sequence archetype type.
+  /// As for \p countType itself, it must be a type parameter pack
+  /// type, or a pack archetype type.
   static PackExpansionType *get(Type pattern, Type countType);
 
 public:
@@ -6548,14 +6542,14 @@ inline bool TypeBase::isTypeParameter() {
   return t->is<GenericTypeParamType>();
 }
 
-inline bool TypeBase::isTypeSequenceParameter() {
+inline bool TypeBase::isParameterPack() {
   Type t(this);
 
   while (auto *memberTy = t->getAs<DependentMemberType>())
     t = memberTy->getBase();
 
   return t->is<GenericTypeParamType>() &&
-         t->castTo<GenericTypeParamType>()->isTypeSequence();
+         t->castTo<GenericTypeParamType>()->isParameterPack();
 }
 
 // TODO: This will become redundant once InOutType is removed.
@@ -6842,7 +6836,7 @@ constexpr bool TypeBase::isSugaredType<id##Type>() { \
 #include "swift/AST/TypeNodes.def"
 
 inline GenericParamKey::GenericParamKey(const GenericTypeParamType *p)
-    : TypeSequence(p->isTypeSequence()), Depth(p->getDepth()),
+    : ParameterPack(p->isParameterPack()), Depth(p->getDepth()),
       Index(p->getIndex()) {}
 
 inline TypeBase *TypeBase::getDesugaredType() {

include/swift/Sema/Constraint.h

@@ -307,10 +307,6 @@ enum class ConversionRestrictionKind {
   ///    - Unsafe[Mutable]RawPointer -> Unsafe[Mutable]Pointer<[U]Int>
   ///    - Unsafe[Mutable]Pointer<Int{8, 16, ...}> <-> Unsafe[Mutable]Pointer<UInt{8, 16, ...}>
   PointerToCPointer,
-  // Convert a pack into a type with an equivalent arity.
-  // - If the arity of the pack is 1, drops the pack structure <T> => T
-  // - If the arity of the pack is n >= 1, converts the pack structure into a tuple <T, U, V> => (T, U, V)
-  ReifyPackToType,
 };
 
 /// Specifies whether a given conversion requires the creation of a temporary

include/swift/Sema/ConstraintLocator.h

@@ -792,9 +792,9 @@ class LocatorPathElt::GenericParameter final : public StoredPointerElement<Gener
   GenericTypeParamType *getType() const {
     return getStoredPointer();
   }
-    
-  bool isTypeSequence() const {
-    return getType()->isTypeSequence();
+
+  bool isParameterPack() const {
+    return getType()->isParameterPack();
   }
 
   static bool classof(const LocatorPathElt *elt) {