AST: Replace TupleTypeRepr's ellipsis with PackExpansionTypeRepr

Author: slavapestov

include/swift/AST/Decl.h

@@ -5904,10 +5904,8 @@ class ParamDecl : public VarDecl {
 
   void setDefaultValueStringRepresentation(StringRef stringRepresentation);
 
-  /// Whether or not this parameter is varargs.
-  bool isVariadic() const {
-    return DefaultValueAndFlags.getInt().contains(Flags::IsVariadic);
-  }
+  /// Whether or not this parameter is old-style variadic.
+  bool isVariadic() const;
   void setVariadic(bool value = true) {
     auto flags = DefaultValueAndFlags.getInt();
     DefaultValueAndFlags.setInt(value ? flags | Flags::IsVariadic

include/swift/AST/DiagnosticsParse.def

@@ -852,8 +852,6 @@ NOTE(subscript_array_element_fix_it_remove_space, none,
 // Tuple Types
 ERROR(expected_rparen_tuple_type_list,none,
       "expected ')' at end of tuple list", ())
-ERROR(multiple_ellipsis_in_tuple,none,
-      "only a single element can be variadic", ())
 ERROR(tuple_type_init,none,
       "default argument not permitted in a tuple type", ())
 ERROR(protocol_method_argument_init,none,
@@ -959,8 +957,6 @@ ERROR(expected_parameter_colon,PointsToFirstBadToken,
       "expected ':' following argument label and parameter name", ())
 ERROR(expected_assignment_instead_of_comparison_operator,none,
       "expected '=' instead of '==' to assign default value for parameter", ())
-ERROR(parameter_vararg_default,none,
-      "variadic parameter cannot have a default value", ())
 ERROR(parameter_specifier_as_attr_disallowed,none,
       "'%0' before a parameter name is not allowed, place it before the parameter type instead",
       (StringRef))
@@ -995,11 +991,6 @@ ERROR(false_available_is_called_unavailable,none,
 ERROR(initializer_as_typed_pattern,none,
       "unexpected initializer in pattern; did you mean to use '='?", ())
 
-ERROR(unlabeled_parameter_following_variadic_parameter,none,
-      "a parameter following a variadic parameter requires a label", ())
-ERROR(closure_unlabeled_parameter_following_variadic_parameter,none,
-      "no parameters may follow a variadic parameter in a closure", ())
-
 ERROR(enum_element_empty_arglist,none,
       "enum element with associated values must have at least one "
       "associated value", ())

include/swift/AST/DiagnosticsSema.def

@@ -5014,14 +5014,22 @@ ERROR(dot_protocol_on_non_existential,none,
       "cannot use 'Protocol' with non-protocol type %0", (Type))
 ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
-ERROR(tuple_ellipsis,none,
-      "cannot create a variadic tuple", ())
 ERROR(expansion_not_variadic,none,
       "cannot create expansion with non-variadic type %0", (Type))
 ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
+ERROR(multiple_ellipsis_in_tuple,none,
+      "only a single element can be variadic", ())
+
 ERROR(enum_element_ellipsis,none,
       "variadic enum cases are not supported", ())
+ERROR(unlabeled_parameter_following_variadic_parameter,none,
+      "a parameter following a variadic parameter requires a label", ())
+ERROR(closure_unlabeled_parameter_following_variadic_parameter,none,
+      "no parameters may follow a variadic parameter in a closure", ())
+
+ERROR(parameter_vararg_default,none,
+      "variadic parameter cannot have a default value", ())
 
 WARNING(implicitly_unwrapped_optional_in_illegal_position_interpreted_as_optional,none,
         "using '!' is not allowed here; treating this as '?' instead", ())
@@ -5142,8 +5150,6 @@ ERROR(opened_bad_constraint_type,none,
       "@opened constraint type %0 is not a protocol or protocol composition", (Type))
 ERROR(opened_bad_interface_type,none,
       "@opened interface type %0 is not a type parameter", (Type))
-ERROR(sil_function_ellipsis,PointsToFirstBadToken,
-      "SIL function types cannot be variadic", ())
 ERROR(sil_function_input_label,PointsToFirstBadToken,
       "SIL function types cannot have labeled inputs", ())
 ERROR(sil_function_output_label,PointsToFirstBadToken,

include/swift/AST/TypeRepr.h

@@ -73,10 +73,7 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     Warned : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(TupleTypeRepr, TypeRepr, 1+32,
-    /// Whether this tuple has '...' and its position.
-    HasEllipsis : 1,
-    : NumPadBits,
+  SWIFT_INLINE_BITFIELD_FULL(TupleTypeRepr, TypeRepr, 32,
     /// The number of elements contained.
     NumElements : 32
   );
@@ -754,19 +751,16 @@ class PackExpansionTypeRepr final : public TypeRepr {
 ///   (_ x: Foo)
 /// \endcode
 class TupleTypeRepr final : public TypeRepr,
-    private llvm::TrailingObjects<TupleTypeRepr, TupleTypeReprElement,
-                                  Located<unsigned>> {
+    private llvm::TrailingObjects<TupleTypeRepr, TupleTypeReprElement> {
   friend TrailingObjects;
-  typedef Located<unsigned> SourceLocAndIdx;
 
   SourceRange Parens;
 
   size_t numTrailingObjects(OverloadToken<TupleTypeReprElement>) const {
     return Bits.TupleTypeRepr.NumElements;
   }
 
-  TupleTypeRepr(ArrayRef<TupleTypeReprElement> Elements,
-                SourceRange Parens, SourceLoc Ellipsis, unsigned EllipsisIdx);
+  TupleTypeRepr(ArrayRef<TupleTypeReprElement> Elements, SourceRange Parens);
 
 public:
   unsigned getNumElements() const { return Bits.TupleTypeRepr.NumElements; }
@@ -822,47 +816,15 @@ class TupleTypeRepr final : public TypeRepr,
 
   SourceRange getParens() const { return Parens; }
 
-  bool hasEllipsis() const {
-    return Bits.TupleTypeRepr.HasEllipsis;
-  }
-
-  SourceLoc getEllipsisLoc() const {
-    return hasEllipsis() ?
-      getTrailingObjects<SourceLocAndIdx>()[0].Loc : SourceLoc();
-  }
-
-  unsigned getEllipsisIndex() const {
-    return hasEllipsis() ?
-      getTrailingObjects<SourceLocAndIdx>()[0].Item :
-        Bits.TupleTypeRepr.NumElements;
-  }
-
-  void removeEllipsis() {
-    if (hasEllipsis()) {
-      Bits.TupleTypeRepr.HasEllipsis = false;
-      getTrailingObjects<SourceLocAndIdx>()[0] = {
-        getNumElements(),
-        SourceLoc()
-      };
-    }
-  }
-
   bool isParenType() const {
     return Bits.TupleTypeRepr.NumElements == 1 &&
            getElementNameLoc(0).isInvalid() &&
-           !hasEllipsis();
+           !isa<PackExpansionTypeRepr>(getElementType(0));
   }
 
   static TupleTypeRepr *create(const ASTContext &C,
                                ArrayRef<TupleTypeReprElement> Elements,
-                               SourceRange Parens,
-                               SourceLoc Ellipsis, unsigned EllipsisIdx);
-  static TupleTypeRepr *create(const ASTContext &C,
-                               ArrayRef<TupleTypeReprElement> Elements,
-                               SourceRange Parens) {
-    return create(C, Elements, Parens,
-                  SourceLoc(), Elements.size());
-  }
+                               SourceRange Parens);
   static TupleTypeRepr *createEmpty(const ASTContext &C, SourceRange Parens);
 
   static bool classof(const TypeRepr *T) {

include/swift/Parse/Parser.h

@@ -1316,6 +1316,10 @@ class Parser {
     CustomAttribute,
   };
 
+  ParserResult<TypeRepr> parseTypeScalar(
+      Diag<> MessageID,
+      ParseTypeReason reason);
+
   ParserResult<TypeRepr> parseType();
   ParserResult<TypeRepr> parseType(
       Diag<> MessageID,
@@ -1433,9 +1437,6 @@ class Parser {
     /// \p SecondName is the name.
     SourceLoc SecondNameLoc;
 
-    /// The location of the '...', if present.
-    SourceLoc EllipsisLoc;
-
     /// The first name.
     Identifier FirstName;
 

lib/AST/ASTDumper.cpp

@@ -960,8 +960,9 @@ namespace {
         }
       }
 
-      if (P->isVariadic())
-        OS << " variadic";
+      if (P->hasInterfaceType())
+        if (P->isVariadic())
+          OS << " variadic";
 
       if (P->isAutoClosure())
         OS << " autoclosure";

lib/AST/ASTPrinter.cpp

@@ -3832,13 +3832,6 @@ void PrintAST::printOneParameter(const ParamDecl *param,
     TheTypeLoc = TypeLoc::withoutLoc(param->getInterfaceType());
   }
 
-  // If the parameter is variadic, we will print the "..." after it, but we have
-  // to strip off the added array type.
-  if (param->isVariadic() && TheTypeLoc.getType()) {
-    if (auto *BGT = TheTypeLoc.getType()->getAs<BoundGenericType>())
-      TheTypeLoc.setType(BGT->getGenericArgs()[0]);
-  }
-
   {
     Printer.printStructurePre(PrintStructureKind::FunctionParameterType);
     SWIFT_DEFER {
@@ -3853,9 +3846,6 @@ void PrintAST::printOneParameter(const ParamDecl *param,
 
     printTypeLocForImplicitlyUnwrappedOptional(
       TheTypeLoc, param->isImplicitlyUnwrappedOptional());
-
-    if (param->isVariadic())
-      Printer << "...";
   }
 
   if (param->isDefaultArgument() && Options.PrintDefaultArgumentValue) {

lib/AST/Decl.cpp

@@ -1873,10 +1873,6 @@ static bool isDefaultInitializable(const TypeRepr *typeRepr, ASTContext &ctx) {
   // Tuple types are default-initializable if all of their element
   // types are.
   if (const auto tuple = dyn_cast<TupleTypeRepr>(typeRepr)) {
-    // ... but not variadic ones.
-    if (tuple->hasEllipsis())
-      return false;
-
     for (const auto &elt : tuple->getElements()) {
       if (!isDefaultInitializable(elt.Type, ctx))
         return false;
@@ -6530,6 +6526,12 @@ bool ParamDecl::isAnonClosureParam() const {
   return nameStr[0] == '$';
 }
 
+bool ParamDecl::isVariadic() const {
+  (void) getInterfaceType();
+
+  return DefaultValueAndFlags.getInt().contains(Flags::IsVariadic);
+}
+
 ParamDecl::Specifier ParamDecl::getSpecifier() const {
   auto &ctx = getASTContext();
 

lib/AST/NameLookup.cpp

@@ -2811,10 +2811,6 @@ createOpaqueParameterGenericParams(
   SmallVector<GenericTypeParamDecl *, 2> implicitGenericParams;
   auto dc = value->getInnermostDeclContext();
   for (auto param : *params) {
-    // Don't permit variadic parameters.
-    if (param->isVariadic())
-      continue;
-
     auto typeRepr = param->getTypeRepr();
     if (!typeRepr)
       continue;

lib/AST/Type.cpp

@@ -1315,8 +1315,7 @@ ParameterListInfo::ParameterListInfo(
       inheritActorContext.set(i);
     }
 
-    if (param->isVariadic() &&
-        param->getVarargBaseTy()->hasTypeSequence()) {
+    if (param->getInterfaceType()->is<PackExpansionType>()) {
       variadicGenerics.set(i);
     }
   }

lib/AST/TypeRepr.cpp

@@ -120,6 +120,10 @@ CollectedOpaqueReprs TypeRepr::collectOpaqueReturnTypeReprs() {
     explicit Walker(CollectedOpaqueReprs &reprs) : Reprs(reprs) {}
 
     bool walkToTypeReprPre(TypeRepr *repr) override {
+      // Don't allow variadic opaque parameter or return types.
+      if (isa<PackExpansionTypeRepr>(repr))
+        return false;
+
       if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr))
         Reprs.push_back(opaqueRepr);
       return true;
@@ -354,41 +358,26 @@ void ImplicitlyUnwrappedOptionalTypeRepr::printImpl(ASTPrinter &Printer,
 }
 
 TupleTypeRepr::TupleTypeRepr(ArrayRef<TupleTypeReprElement> Elements,
-                             SourceRange Parens,
-                             SourceLoc Ellipsis, unsigned EllipsisIdx)
+                             SourceRange Parens)
     : TypeRepr(TypeReprKind::Tuple), Parens(Parens) {
-  Bits.TupleTypeRepr.HasEllipsis = Ellipsis.isValid();
   Bits.TupleTypeRepr.NumElements = Elements.size();
 
-  // Copy elements.
   std::uninitialized_copy(Elements.begin(), Elements.end(),
                           getTrailingObjects<TupleTypeReprElement>());
-
-  // Set ellipsis location and index.
-  if (Ellipsis.isValid()) {
-    getTrailingObjects<SourceLocAndIdx>()[0] = {EllipsisIdx, Ellipsis};
-  }
 }
 
 TupleTypeRepr *TupleTypeRepr::create(const ASTContext &C,
                                      ArrayRef<TupleTypeReprElement> Elements,
-                                     SourceRange Parens,
-                                     SourceLoc Ellipsis, unsigned EllipsisIdx) {
-  assert(Ellipsis.isValid() ? EllipsisIdx < Elements.size()
-                            : EllipsisIdx == Elements.size());
-
+                                     SourceRange Parens) {
   size_t size =
-    totalSizeToAlloc<TupleTypeReprElement, SourceLocAndIdx>(
-      Elements.size(), Ellipsis.isValid() ? 1 : 0);
+    totalSizeToAlloc<TupleTypeReprElement>(Elements.size());
   void *mem = C.Allocate(size, alignof(TupleTypeRepr));
-  return new (mem) TupleTypeRepr(Elements, Parens,
-                                 Ellipsis, EllipsisIdx);
+  return new (mem) TupleTypeRepr(Elements, Parens);
 }
 
 TupleTypeRepr *TupleTypeRepr::createEmpty(const ASTContext &C,
                                           SourceRange Parens) {
-  return create(C, {}, Parens,
-      /*Ellipsis=*/SourceLoc(), /*EllipsisIdx=*/0);
+  return create(C, {}, Parens);
 }
 
 GenericIdentTypeRepr *GenericIdentTypeRepr::create(const ASTContext &C,
@@ -473,9 +462,6 @@ void TupleTypeRepr::printImpl(ASTPrinter &Printer,
     }
     printTypeRepr(getElementType(i), Printer, Opts);
     Printer.printStructurePost(PrintStructureKind::TupleElement);
-
-    if (hasEllipsis() && getEllipsisIndex() == i)
-      Printer << "...";
   }
 
   Printer << ")";

lib/Parse/ParseDecl.cpp

@@ -6255,7 +6255,6 @@ static AccessorDecl *createAccessorFunc(SourceLoc DeclLoc,
                                      storageParam->getNameLoc(),
                                      storageParam->getName(),
                                      P->CurDeclContext);
-        accessorParam->setVariadic(storageParam->isVariadic());
         accessorParam->setAutoClosure(storageParam->isAutoClosure());
 
         // The cloned parameter is implicit.