AST: Introduce PackExpansionTypeRepr

Author: slavapestov

include/swift/AST/TypeRepr.h

@@ -708,6 +708,45 @@ struct TupleTypeReprElement {
   TupleTypeReprElement(TypeRepr *Type): Type(Type) {}
 };
 
+/// A pack expansion 'T...' with a pattern 'T'.
+///
+/// Can appear in the following positions:
+/// - The type of a parameter declaration in a function declaration
+/// - The type of a parameter in a function type
+/// - The element of a tuple
+///
+/// In the first two cases, it also spells an old-style variadic parameter
+/// desugaring to an array type. The two meanings are distinguished by the
+/// presence of at least one pack type parameter in the pack expansion
+/// pattern.
+///
+/// In the third case, tuples cannot contain an old-style variadic element,
+/// so the pack expansion must be a real variadic pack expansion.
+class PackExpansionTypeRepr final : public TypeRepr {
+  TypeRepr *Pattern;
+  SourceLoc EllipsisLoc;
+
+public:
+  PackExpansionTypeRepr(TypeRepr *Pattern, SourceLoc EllipsisLoc)
+    : TypeRepr(TypeReprKind::PackExpansion), Pattern(Pattern),
+      EllipsisLoc(EllipsisLoc) {}
+
+  TypeRepr *getPatternType() const { return Pattern; }
+  SourceLoc getEllipsisLoc() const { return EllipsisLoc; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::PackExpansion;
+  }
+  static bool classof(const PackExpansionTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const { return Pattern->getStartLoc(); }
+  SourceLoc getEndLocImpl() const { return EllipsisLoc; }
+  SourceLoc getLocImpl() const { return EllipsisLoc; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// A tuple type.
 /// \code
 ///   (Foo, Bar)
@@ -1339,6 +1378,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Dictionary:
   case TypeReprKind::Optional:
   case TypeReprKind::ImplicitlyUnwrappedOptional:
+  case TypeReprKind::PackExpansion:
   case TypeReprKind::Tuple:
   case TypeReprKind::Fixed:
   case TypeReprKind::Array:

include/swift/AST/TypeReprNodes.def

@@ -59,6 +59,7 @@ TYPEREPR(ImplicitlyUnwrappedOptional, TypeRepr)
 TYPEREPR(Tuple, TypeRepr)
 TYPEREPR(Composition, TypeRepr)
 TYPEREPR(Metatype, TypeRepr)
+TYPEREPR(PackExpansion, TypeRepr)
 TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
 TYPEREPR(NamedOpaqueReturn, TypeRepr)

lib/AST/ASTDumper.cpp

@@ -3088,6 +3088,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
+    printCommon("pack_expansion") << '\n';
+    printRec(T->getPatternType());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitTupleTypeRepr(TupleTypeRepr *T) {
     printCommon("type_tuple");
 

lib/AST/ASTWalker.cpp

@@ -1879,6 +1879,9 @@ bool Traversal::visitOptionalTypeRepr(OptionalTypeRepr *T) {
 bool Traversal::visitImplicitlyUnwrappedOptionalTypeRepr(ImplicitlyUnwrappedOptionalTypeRepr *T) {
   return doIt(T->getBase());
 }
+bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
+  return doIt(T->getPatternType());
+}
 
 bool Traversal::visitTupleTypeRepr(TupleTypeRepr *T) {
   for (auto &elem : T->getElements()) {

lib/AST/NameLookup.cpp

@@ -2532,6 +2532,13 @@ directReferencesForTypeRepr(Evaluator &evaluator,
     return { };
   }
 
+  case TypeReprKind::PackExpansion: {
+    auto packExpansionRepr = cast<PackExpansionTypeRepr>(typeRepr);
+    return directReferencesForTypeRepr(evaluator, ctx,
+                                       packExpansionRepr->getPatternType(), dc,
+                                       allowUsableFromInline);
+  }
+
   case TypeReprKind::Error:
   case TypeReprKind::Function:
   case TypeReprKind::InOut:

lib/AST/TypeRepr.cpp

@@ -439,6 +439,12 @@ SourceLoc SILBoxTypeRepr::getLocImpl() const {
   return LBraceLoc;
 }
 
+void PackExpansionTypeRepr::printImpl(ASTPrinter &Printer,
+                                      const PrintOptions &Opts) const {
+  printTypeRepr(Pattern, Printer, Opts);
+  Printer << "...";
+}
+
 void TupleTypeRepr::printImpl(ASTPrinter &Printer,
                               const PrintOptions &Opts) const {
   Printer.callPrintStructurePre(PrintStructureKind::TupleType);

lib/Parse/SyntaxParsingContext.cpp

@@ -277,6 +277,7 @@ void SyntaxParsingContext::createNodeInPlace(SyntaxKind Kind,
   case SyntaxKind::TernaryExpr:
   case SyntaxKind::AvailabilityLabeledArgument:
   case SyntaxKind::MetatypeType:
+  case SyntaxKind::PackExpansionType:
   case SyntaxKind::OptionalType:
   case SyntaxKind::ImplicitlyUnwrappedOptionalType:
   case SyntaxKind::TypeExpr: {

lib/Sema/TypeCheckType.cpp

@@ -2047,6 +2047,11 @@ namespace {
     NeverNullType resolveImplicitlyUnwrappedOptionalType(
         ImplicitlyUnwrappedOptionalTypeRepr *repr,
         TypeResolutionOptions options, bool isDirect);
+    std::pair<Type, Type>
+    maybeResolvePackExpansionType(PackExpansionTypeRepr *repr,
+                                  TypeResolutionOptions options);
+    NeverNullType resolvePackExpansionType(PackExpansionTypeRepr *repr,
+                                           TypeResolutionOptions options);
     NeverNullType resolveTupleType(TupleTypeRepr *repr,
                                    TypeResolutionOptions options);
     NeverNullType resolveCompositionType(CompositionTypeRepr *repr,
@@ -2215,6 +2220,9 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
     return resolveImplicitlyUnwrappedOptionalType(iuoRepr, options, isDirect);
   }
 
+  case TypeReprKind::PackExpansion:
+    return resolvePackExpansionType(cast<PackExpansionTypeRepr>(repr), options);
+
   case TypeReprKind::Tuple:
     return resolveTupleType(cast<TupleTypeRepr>(repr), options);
 
@@ -4008,6 +4016,39 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   return uncheckedOptionalTy;
 }
 
+std::pair<Type, Type>
+TypeResolver::maybeResolvePackExpansionType(PackExpansionTypeRepr *repr,
+                                            TypeResolutionOptions options) {
+  auto elementOptions = options;
+  auto patternTy = resolveType(repr->getPatternType(), elementOptions);
+  if (patternTy->hasError())
+    return std::make_pair(ErrorType::get(getASTContext()), Type());
+
+  // Find the first type sequence parameter and use that as the count type.
+  SmallVector<Type, 1> rootTypeSequenceParams;
+  patternTy->getTypeSequenceParameters(rootTypeSequenceParams);
+
+  if (rootTypeSequenceParams.empty())
+    return std::make_pair(patternTy, Type());
+
+  return std::make_pair(patternTy, rootTypeSequenceParams[0]);
+}
+
+NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr,
+                                                     TypeResolutionOptions options) {
+  auto pair = maybeResolvePackExpansionType(repr, options);
+
+  // If there's no reference to a variadic generic parameter, complain
+  // - the pack won't actually expand to anything meaningful.
+  if (!pair.first->hasError() && !pair.second) {
+    diagnose(repr->getLoc(), diag::expansion_not_variadic, pair.first)
+      .highlight(repr->getSourceRange());
+    return ErrorType::get(getASTContext());
+  }
+
+  return PackExpansionType::get(pair.first, pair.second);
+}
+
 NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
                                              TypeResolutionOptions options) {
   SmallVector<TupleTypeElt, 8> elements;
@@ -4530,6 +4571,7 @@ class ExistentialTypeVisitor
     case TypeReprKind::Isolated:
     case TypeReprKind::Placeholder:
     case TypeReprKind::CompileTimeConst:
+    case TypeReprKind::PackExpansion:
       return false;
     }
   }