Parse Pack{...} types in SIL mode

This is needed for general fidelity in SIL, since generic argument
lists are used for a lot of different things that aren't restricted
from containing multiple packs.  I haven't actually done the work to
use Pack structure to disambiguate the resolution of pack parameters,
but this is a good start.

We'll probably need something like this in source eventually, so
there's no reason to regret adding all the infrastructure for it.

Author: rjmccall

include/swift/AST/DiagnosticsParse.def

@@ -890,6 +890,10 @@ ERROR(deprecated_protocol_composition_single,none,
 ERROR(deprecated_any_composition,none,
       "'protocol<>' syntax has been removed; use 'Any' instead", ())
 
+// Pack Types
+ERROR(expected_rbrace_pack_type_list,none,
+      "expected '}' at end of pack type list", ())
+
 // SIL box Types
 ERROR(sil_box_expected_var_or_let,none,
       "expected 'var' or 'let' to introduce SIL box field type", ())

include/swift/AST/TypeRepr.h

@@ -100,6 +100,11 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     NumFields : 32
   );
 
+  SWIFT_INLINE_BITFIELD_FULL(PackTypeRepr, TypeRepr, 32,
+    /// The number of elements contained.
+    NumElements : 32
+  );
+
   } Bits;
 
   TypeRepr(TypeReprKind K) {
@@ -758,6 +763,54 @@ class PackExpansionTypeRepr final : public TypeRepr {
   friend class TypeRepr;
 };
 
+/// An explicit pack grouping, `Pack{...}`.
+///
+/// This allows packs to be explicitly grouped.  It is currently only
+/// allowed in SIL files.
+class PackTypeRepr final
+    : public TypeRepr,
+      private llvm::TrailingObjects<PackTypeRepr, TypeRepr *> {
+  friend TrailingObjects;
+  SourceLoc KeywordLoc;
+  SourceRange BraceLocs;
+
+  size_t numTrailingObjects(OverloadToken<TypeRepr*>) const {
+    return Bits.PackTypeRepr.NumElements;
+  }
+
+  PackTypeRepr(SourceLoc keywordLoc, SourceRange braceLocs,
+               ArrayRef<TypeRepr*> elements);
+public:
+  static PackTypeRepr *create(const ASTContext &ctx,
+                              SourceLoc keywordLoc,
+                              SourceRange braceLocs,
+                              ArrayRef<TypeRepr*> elements);
+
+  SourceLoc getKeywordLoc() const { return KeywordLoc; }
+  SourceRange getBracesRange() const { return BraceLocs; }
+
+  MutableArrayRef<TypeRepr*> getMutableElements() {
+    return llvm::makeMutableArrayRef(getTrailingObjects<TypeRepr*>(),
+                                     Bits.PackTypeRepr.NumElements);
+  }
+  ArrayRef<TypeRepr*> getElements() const {
+    return llvm::makeArrayRef(getTrailingObjects<TypeRepr*>(),
+                              Bits.PackTypeRepr.NumElements);
+  }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Pack;
+  }
+  static bool classof(const PackTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const { return KeywordLoc; }
+  SourceLoc getEndLocImpl() const { return BraceLocs.End; }
+  SourceLoc getLocImpl() const { return KeywordLoc; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// A pack reference spelled with the \c each keyword.
 ///
 /// Pack references can only appear inside pack expansions and in
@@ -1398,6 +1451,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::ImplicitlyUnwrappedOptional:
   case TypeReprKind::Vararg:
   case TypeReprKind::PackExpansion:
+  case TypeReprKind::Pack:
   case TypeReprKind::Tuple:
   case TypeReprKind::Fixed:
   case TypeReprKind::Array:

include/swift/AST/TypeReprNodes.def

@@ -65,6 +65,7 @@ TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
 TYPEREPR(NamedOpaqueReturn, TypeRepr)
 TYPEREPR(Existential, TypeRepr)
+TYPEREPR(Pack, TypeRepr)
 TYPEREPR(PackReference, TypeRepr)
 TYPEREPR(Placeholder, TypeRepr)
 ABSTRACT_TYPEREPR(Specifier, TypeRepr)

lib/AST/ASTDumper.cpp

@@ -3174,6 +3174,13 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitPackTypeRepr(PackTypeRepr *T) {
+    printCommon("pack") << '\n';
+    for (auto elt : T->getElements())
+      printRec(elt);
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
     printCommon("pack_expansion") << '\n';
     printRec(T->getPatternType());

lib/AST/ASTWalker.cpp

@@ -2007,6 +2007,13 @@ bool Traversal::visitVarargTypeRepr(VarargTypeRepr *T) {
   return doIt(T->getElementType());
 }
 
+bool Traversal::visitPackTypeRepr(PackTypeRepr *T) {
+  for (auto &elem : T->getMutableElements())
+    if (doIt(elem))
+      return true;
+  return false;
+}
+
 bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
   return doIt(T->getPatternType());
 }

lib/AST/NameLookup.cpp

@@ -2552,6 +2552,7 @@ directReferencesForTypeRepr(Evaluator &evaluator,
   case TypeReprKind::Shared:
   case TypeReprKind::SILBox:
   case TypeReprKind::Placeholder:
+  case TypeReprKind::Pack:
     return { };
 
   case TypeReprKind::OpaqueReturn:

lib/AST/TypeRepr.cpp

@@ -397,6 +397,24 @@ MemberTypeRepr *MemberTypeRepr::create(const ASTContext &Ctx,
   return create(Ctx, Components.front(), Components.drop_front());
 }
 
+PackTypeRepr::PackTypeRepr(SourceLoc keywordLoc, SourceRange braceLocs,
+                           ArrayRef<TypeRepr*> elements)
+  : TypeRepr(TypeReprKind::Pack),
+    KeywordLoc(keywordLoc), BraceLocs(braceLocs) {
+  Bits.PackTypeRepr.NumElements = elements.size();
+  memcpy(getTrailingObjects<TypeRepr*>(), elements.data(),
+         elements.size() * sizeof(TypeRepr*));
+}
+
+PackTypeRepr *PackTypeRepr::create(const ASTContext &ctx,
+                                   SourceLoc keywordLoc,
+                                   SourceRange braceLocs,
+                                   ArrayRef<TypeRepr*> elements) {
+  auto size = totalSizeToAlloc<TypeRepr*>(elements.size());
+  auto mem = ctx.Allocate(size, alignof(PackTypeRepr));
+  return new (mem) PackTypeRepr(keywordLoc, braceLocs, elements);
+}
+
 SILBoxTypeRepr *SILBoxTypeRepr::create(ASTContext &C,
                       GenericParamList *GenericParams,
                       SourceLoc LBraceLoc, ArrayRef<Field> Fields,
@@ -434,6 +452,18 @@ void VarargTypeRepr::printImpl(ASTPrinter &Printer,
   Printer << "...";
 }
 
+void PackTypeRepr::printImpl(ASTPrinter &Printer,
+                             const PrintOptions &Opts) const {
+  Printer.printKeyword("Pack", Opts);
+  Printer << "{";
+  auto elts = getElements();
+  for (size_t i = 0, e = elts.size(); i != e; ++i) {
+    if (i) Printer << ", ";
+    printTypeRepr(elts[i], Printer, Opts);
+  }
+  Printer << "}";
+}
+
 void PackExpansionTypeRepr::printImpl(ASTPrinter &Printer,
                                       const PrintOptions &Opts) const {
   Printer.printKeyword("repeat", Opts, /*Suffix=*/" ");

lib/Parse/ParseType.cpp

@@ -160,6 +160,7 @@ LayoutConstraint Parser::parseLayoutConstraint(Identifier LayoutConstraintID) {
 ///     type-collection
 ///     type-array
 ///     '_'
+///     'Pack' '{' (type (',' type)*)? '}'    (only in SIL files)a
 ParserResult<TypeRepr> Parser::parseTypeSimple(
     Diag<> MessageID, ParseTypeReason reason) {
   ParserResult<TypeRepr> ty;
@@ -700,6 +701,34 @@ Parser::parseTypeIdentifier(bool isParsingQualifiedDeclBaseType) {
 
     return nullptr;
   }
+
+  // In SIL files (not just when parsing SIL types), accept the
+  // Pack{} syntax for spelling variadic type packs.
+  if (SIL && Tok.isContextualKeyword("Pack") &&
+      peekToken().is(tok::l_brace)) {
+    TokReceiver->registerTokenKindChange(Tok.getLoc(), tok::contextual_keyword);
+    SourceLoc keywordLoc = consumeToken(tok::identifier);
+    SourceLoc lbLoc = consumeToken(tok::l_brace);
+    SourceLoc rbLoc;
+    SmallVector<TypeRepr*, 8> elements;
+    auto status = parseList(tok::r_brace, lbLoc, rbLoc,
+                            /*AllowSepAfterLast=*/false,
+                            diag::expected_rbrace_pack_type_list,
+                            [&] () -> ParserStatus {
+      auto element = parseType(diag::expected_type);
+      if (element.hasCodeCompletion())
+        return makeParserCodeCompletionStatus();
+      if (element.isNull())
+        return makeParserError();
+      elements.push_back(element.get());
+      return makeParserSuccess();
+    });
+
+    return makeParserResult(status,
+        PackTypeRepr::create(Context, keywordLoc, SourceRange(lbLoc, rbLoc),
+                             elements));
+  }
+
   ParserStatus Status;
   SmallVector<IdentTypeRepr *, 4> ComponentsR;
   SourceLoc EndLoc;

lib/Sema/TypeCheckType.cpp

@@ -141,6 +141,7 @@ static unsigned getGenericRequirementKind(TypeResolutionOptions options) {
   case TypeResolverContext::None:
   case TypeResolverContext::Inherited:
   case TypeResolverContext::FunctionInput:
+  case TypeResolverContext::PackElement:
   case TypeResolverContext::TupleElement:
   case TypeResolverContext::GenericArgument:
   case TypeResolverContext::ProtocolGenericArgument:
@@ -2034,6 +2035,8 @@ namespace {
                                   TypeResolutionOptions options);
     NeverNullType resolveVarargType(VarargTypeRepr *repr,
                                     TypeResolutionOptions options);
+    NeverNullType resolvePackType(PackTypeRepr *repr,
+                                  TypeResolutionOptions options);
     NeverNullType resolvePackExpansionType(PackExpansionTypeRepr *repr,
                                            TypeResolutionOptions options);
     NeverNullType resolvePackReference(PackReferenceTypeRepr *repr,
@@ -2231,6 +2234,9 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
   case TypeReprKind::Vararg:
     return resolveVarargType(cast<VarargTypeRepr>(repr), options);
 
+  case TypeReprKind::Pack:
+    return resolvePackType(cast<PackTypeRepr>(repr), options);
+
   case TypeReprKind::PackExpansion:
     return resolvePackExpansionType(cast<PackExpansionTypeRepr>(repr), options);
 
@@ -4108,6 +4114,7 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   case TypeResolverContext::PatternBindingDecl:
     doDiag = !isDirect;
     break;
+  case TypeResolverContext::PackElement:
   case TypeResolverContext::TupleElement:
   case TypeResolverContext::GenericArgument:
   case TypeResolverContext::ProtocolGenericArgument:
@@ -4220,6 +4227,32 @@ NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
   return element;
 }
 
+NeverNullType TypeResolver::resolvePackType(PackTypeRepr *repr,
+                                            TypeResolutionOptions options) {
+  // This form is currently only allowed in SIL, so we're lax about
+  // where we allow this.  If this is ever made a proper language feature,
+  // it should only be allowed in contexts where an expansion would be
+  // allowed and where structure could be ambiguous.  That really just
+  // means generic argument lists.
+  //
+  // Its presence should also affect how arguments are implicitly grouped
+  // into packs, of course.
+
+  auto elementReprs = repr->getElements();
+  SmallVector<Type, 8> elementTypes;
+  elementTypes.reserve(elementReprs.size());
+
+  auto elementOptions = options;
+  elementOptions.setContext(TypeResolverContext::PackElement);
+
+  for (auto elementRepr : elementReprs) {
+    auto elementType = resolveType(elementRepr, elementOptions);
+    elementTypes.push_back(elementType);
+  }
+
+  return PackType::get(getASTContext(), elementTypes);
+}
+
 NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr,
                                                      TypeResolutionOptions options) {
   auto &ctx = getASTContext();
@@ -4789,6 +4822,7 @@ class ExistentialTypeVisitor
     case TypeReprKind::Placeholder:
     case TypeReprKind::CompileTimeConst:
     case TypeReprKind::Vararg:
+    case TypeReprKind::Pack:
     case TypeReprKind::PackExpansion:
     case TypeReprKind::PackReference:
       return false;

lib/Sema/TypeCheckType.h

@@ -92,6 +92,9 @@ enum class TypeResolverContext : uint8_t {
   /// Whether we are checking a tuple element type.
   TupleElement,
 
+  /// Whether we are checking a pack element type.
+  PackElement,
+
   /// Whether we are checking the parameter list of a function.
   AbstractFunctionDecl,
 
@@ -253,6 +256,7 @@ class TypeResolutionOptions {
     case Context::GenericArgument:
     case Context::ProtocolGenericArgument:
     case Context::TupleElement:
+    case Context::PackElement:
     case Context::FunctionInput:
     case Context::VariadicFunctionInput:
     case Context::InoutFunctionInput:
@@ -297,6 +301,7 @@ class TypeResolutionOptions {
     case Context::None:
     case Context::GenericArgument:
     case Context::ProtocolGenericArgument:
+    case Context::PackElement:
     case Context::TupleElement:
     case Context::InExpression:
     case Context::ExplicitCastExpr:
@@ -326,6 +331,7 @@ class TypeResolutionOptions {
     switch (context) {
     case Context::FunctionInput:
     case Context::VariadicFunctionInput:
+    case Context::PackElement:
     case Context::TupleElement:
     case Context::GenericArgument:
       return true;
@@ -379,6 +385,7 @@ class TypeResolutionOptions {
     case Context::None:
     case Context::Inherited:
     case Context::FunctionInput:
+    case Context::PackElement:
     case Context::TupleElement:
     case Context::GenericArgument:
     case Context::ProtocolGenericArgument: