[AST] Introduce a syntactic distinction betweek vararg type reprs and

hborla · hborla · commit 74bf2f3e7a57 · 2023-01-07T09:50:11.000-08:00
pack expansion type reprs.

Classic variadic parameters still use the postfix ellipsis syntax, and
pack expansion types now use a prefix 'repeat' keyword.
diff --git a/include/swift/AST/CASTBridging.h b/include/swift/AST/CASTBridging.h
@@ -239,7 +239,7 @@ void *ImplicitlyUnwrappedOptionalTypeRepr_create(void *ctx, void *base,
                                                  void *exclamationLoc);
 void *MetatypeTypeRepr_create(void *ctx, void *baseType, void *typeLoc);
 void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc);
-void *PackExpansionTypeRepr_create(void *ctx, void *base, void *ellipsisLoc);
+void *PackExpansionTypeRepr_create(void *ctx, void *base, void *repeatLoc);
 void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
                            void *rParenLoc);
 void *DeclRefTypeRepr_create(void *ctx, BridgedArrayRef bridgedComponents);
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -5163,6 +5163,9 @@ 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(vararg_not_allowed,none,
+      "variadic parameter cannot appear outside of a function parameter list",
+      ())
 ERROR(expansion_not_allowed,none,
       "variadic expansion %0 cannot appear outside of a function parameter list, "
       "function result, tuple element or generic argument list", (Type))
diff --git a/include/swift/AST/TypeRepr.h b/include/swift/AST/TypeRepr.h
@@ -693,6 +693,32 @@ struct TupleTypeReprElement {
   TupleTypeReprElement(TypeRepr *Type): Type(Type) {}
 };
 
+/// A vararg type 'T...' with element type 'T'.
+class VarargTypeRepr final : public TypeRepr {
+  TypeRepr *Element;
+  SourceLoc EllipsisLoc;
+
+public:
+  VarargTypeRepr(TypeRepr *Element, SourceLoc EllipsisLoc)
+  : TypeRepr(TypeReprKind::Vararg), Element(Element),
+    EllipsisLoc(EllipsisLoc) {}
+
+  TypeRepr *getElementType() const { return Element; }
+  SourceLoc getEllipsisLoc() const { return EllipsisLoc; }
+
+  static bool classof(const TypeRepr *T) {
+    return T->getKind() == TypeReprKind::Vararg;
+  }
+  static bool classof(const VarargTypeRepr *T) { return true; }
+
+private:
+  SourceLoc getStartLocImpl() const { return Element->getEndLoc(); }
+  SourceLoc getEndLocImpl() const { return EllipsisLoc; }
+  SourceLoc getLocImpl() const { return EllipsisLoc; }
+  void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
+  friend class TypeRepr;
+};
+
 /// A pack expansion 'T...' with a pattern 'T'.
 ///
 /// Can appear in the following positions:
@@ -708,26 +734,26 @@ struct TupleTypeReprElement {
 /// 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 {
+  SourceLoc RepeatLoc;
   TypeRepr *Pattern;
-  SourceLoc EllipsisLoc;
 
 public:
-  PackExpansionTypeRepr(TypeRepr *Pattern, SourceLoc EllipsisLoc)
-    : TypeRepr(TypeReprKind::PackExpansion), Pattern(Pattern),
-      EllipsisLoc(EllipsisLoc) {}
+  PackExpansionTypeRepr(SourceLoc RepeatLoc, TypeRepr *Pattern)
+    : TypeRepr(TypeReprKind::PackExpansion), RepeatLoc(RepeatLoc),
+      Pattern(Pattern) {}
 
+  SourceLoc getRepeatLoc() const { return RepeatLoc; }
   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; }
+  SourceLoc getStartLocImpl() const { return RepeatLoc; }
+  SourceLoc getEndLocImpl() const { return Pattern->getEndLoc(); }
+  SourceLoc getLocImpl() const { return RepeatLoc; }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
   friend class TypeRepr;
 };
@@ -1370,6 +1396,7 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::Dictionary:
   case TypeReprKind::Optional:
   case TypeReprKind::ImplicitlyUnwrappedOptional:
+  case TypeReprKind::Vararg:
   case TypeReprKind::PackExpansion:
   case TypeReprKind::Tuple:
   case TypeReprKind::Fixed:
diff --git a/include/swift/AST/TypeReprNodes.def b/include/swift/AST/TypeReprNodes.def
@@ -59,6 +59,7 @@ TYPEREPR(ImplicitlyUnwrappedOptional, TypeRepr)
 TYPEREPR(Tuple, TypeRepr)
 TYPEREPR(Composition, TypeRepr)
 TYPEREPR(Metatype, TypeRepr)
+TYPEREPR(Vararg, TypeRepr)
 TYPEREPR(PackExpansion, TypeRepr)
 TYPEREPR(Protocol, TypeRepr)
 TYPEREPR(OpaqueReturn, TypeRepr)
diff --git a/lib/AST/ASTDumper.cpp b/lib/AST/ASTDumper.cpp
@@ -3168,6 +3168,12 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
+  void visitVarargTypeRepr(VarargTypeRepr *T) {
+    printCommon("vararg") << '\n';
+    printRec(T->getElementType());
+    PrintWithColorRAII(OS, ParenthesisColor) << ')';
+  }
+
   void visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
     printCommon("pack_expansion") << '\n';
     printRec(T->getPatternType());
diff --git a/lib/AST/ASTWalker.cpp b/lib/AST/ASTWalker.cpp
@@ -2002,6 +2002,11 @@ bool Traversal::visitOptionalTypeRepr(OptionalTypeRepr *T) {
 bool Traversal::visitImplicitlyUnwrappedOptionalTypeRepr(ImplicitlyUnwrappedOptionalTypeRepr *T) {
   return doIt(T->getBase());
 }
+
+bool Traversal::visitVarargTypeRepr(VarargTypeRepr *T) {
+  return doIt(T->getElementType());
+}
+
 bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {
   return doIt(T->getPatternType());
 }
diff --git a/lib/AST/CASTBridging.cpp b/lib/AST/CASTBridging.cpp
@@ -466,10 +466,10 @@ void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc) {
   return new (Context) ProtocolTypeRepr((TypeRepr *)baseType, protocolLoc);
 }
 
-void *PackExpansionTypeRepr_create(void *ctx, void *base, void *ellipsisLoc) {
+void *PackExpansionTypeRepr_create(void *ctx, void *base, void *repeatLoc) {
   ASTContext &Context = *static_cast<ASTContext *>(ctx);
   return new (Context) PackExpansionTypeRepr(
-      (TypeRepr *)base, getSourceLocFromPointer(ellipsisLoc));
+      getSourceLocFromPointer(repeatLoc), (TypeRepr *)base);
 }
 
 void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -2520,6 +2520,13 @@ directReferencesForTypeRepr(Evaluator &evaluator,
     return { };
   }
 
+  case TypeReprKind::Vararg: {
+    auto packExpansionRepr = cast<VarargTypeRepr>(typeRepr);
+    return directReferencesForTypeRepr(evaluator, ctx,
+                                       packExpansionRepr->getElementType(), dc,
+                                       allowUsableFromInline);
+  }
+
   case TypeReprKind::PackExpansion: {
     auto packExpansionRepr = cast<PackExpansionTypeRepr>(typeRepr);
     return directReferencesForTypeRepr(evaluator, ctx,
@@ -2824,7 +2831,7 @@ CollectedOpaqueReprs swift::collectOpaqueReturnTypeReprs(TypeRepr *r, ASTContext
     PreWalkAction walkToTypeReprPre(TypeRepr *repr) override {
 
       // Don't allow variadic opaque parameter or return types.
-      if (isa<PackExpansionTypeRepr>(repr))
+      if (isa<PackExpansionTypeRepr>(repr) || isa<VarargTypeRepr>(repr))
         return Action::SkipChildren();
 
       if (auto opaqueRepr = dyn_cast<OpaqueReturnTypeRepr>(repr)) {
diff --git a/lib/AST/TypeRepr.cpp b/lib/AST/TypeRepr.cpp
@@ -428,10 +428,16 @@ SourceLoc SILBoxTypeRepr::getLocImpl() const {
   return LBraceLoc;
 }
 
+void VarargTypeRepr::printImpl(ASTPrinter &Printer,
+                               const PrintOptions &Opts) const {
+  printTypeRepr(Element, Printer, Opts);
+  Printer << "...";
+}
+
 void PackExpansionTypeRepr::printImpl(ASTPrinter &Printer,
                                       const PrintOptions &Opts) const {
+  Printer.printKeyword("repeat", Opts, /*Suffix=*/" ");
   printTypeRepr(Pattern, Printer, Opts);
-  Printer << "...";
 }
 
 void PackReferenceTypeRepr::printImpl(ASTPrinter &Printer,
diff --git a/lib/ASTGen/Sources/ASTGen/Types.swift b/lib/ASTGen/Sources/ASTGen/Types.swift
@@ -118,8 +118,8 @@ extension ASTGenVisitor {
 
   public func visit(_ node: PackExpansionTypeSyntax) -> ASTNode {
     let base = visit(node.patternType).rawValue
-    let ellipsisLoc = self.base.advanced(by: node.ellipsis.position.utf8Offset).raw
-    return .type(PackExpansionTypeRepr_create(self.ctx, base, ellipsisLoc))
+    let repeatLoc = self.base.advanced(by: node.repeatKeyword.position.utf8Offset).raw
+    return .type(PackExpansionTypeRepr_create(self.ctx, base, repeatLoc))
   }
 
   public func visit(_ node: TupleTypeSyntax) -> ASTNode {
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -2972,7 +2972,8 @@ ParserResult<Expr> Parser::parseTupleOrParenExpr(tok leftTok, tok rightTok) {
 
   // A tuple with a single, unlabeled element is just parentheses.
   if (Context.LangOpts.hasFeature(Feature::VariadicGenerics)) {
-    if (elts.size() == 1 && elts[0].LabelLoc.isInvalid()) {
+    if (elts.size() == 1 && !isa<PackExpansionExpr>(elts[0].E) &&
+        elts[0].LabelLoc.isInvalid()) {
       return makeParserResult(
           status, new (Context) ParenExpr(leftLoc, elts[0].E, rightLoc));
     }
diff --git a/lib/Parse/ParseType.cpp b/lib/Parse/ParseType.cpp
@@ -535,16 +535,28 @@ ParserResult<TypeRepr> Parser::parseTypeScalar(
 ///
 ParserResult<TypeRepr> Parser::parseType(
     Diag<> MessageID, ParseTypeReason reason) {
+  // Parse pack expansion 'repeat T'
+  if (Tok.is(tok::kw_repeat)) {
+    SourceLoc repeatLoc = consumeToken(tok::kw_repeat);
+
+    auto ty = parseTypeScalar(MessageID, reason);
+    if (ty.isNull())
+      return ty;
+
+    return makeParserResult(ty,
+        new (Context) PackExpansionTypeRepr(repeatLoc, ty.get()));
+  }
+
   auto ty = parseTypeScalar(MessageID, reason);
   if (ty.isNull())
     return ty;
 
-  // Parse pack expansion 'T...'.
+  // Parse vararg type 'T...'.
   if (Tok.isEllipsis()) {
     Tok.setKind(tok::ellipsis);
     SourceLoc ellipsisLoc = consumeToken();
     ty = makeParserResult(ty,
-        new (Context) PackExpansionTypeRepr(ty.get(), ellipsisLoc));
+        new (Context) VarargTypeRepr(ty.get(), ellipsisLoc));
   }
 
   return ty;
@@ -1400,6 +1412,9 @@ bool Parser::canParseGenericArguments() {
 }
 
 bool Parser::canParseType() {
+  // 'repeat' starts a pack expansion type.
+  consumeIf(tok::kw_repeat);
+
   // Accept 'inout' at for better recovery.
   consumeIf(tok::kw_inout);
 
diff --git a/lib/Sema/CSGen.cpp b/lib/Sema/CSGen.cpp
@@ -3053,6 +3053,9 @@ namespace {
     Type visitPackElementExpr(PackElementExpr *expr) {
       auto packType = CS.getType(expr->getPackRefExpr());
 
+      if (PackElementEnvironments.empty())
+        return Type();
+
       // The type of a PackElementExpr is the opened pack element archetype
       // of the pack reference.
       OpenPackElementType openPackElement(CS, CS.getConstraintLocator(expr),
diff --git a/lib/Sema/PreCheckExpr.cpp b/lib/Sema/PreCheckExpr.cpp
@@ -1774,6 +1774,11 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
     SmallVector<TupleTypeReprElement, 4> Elts;
     unsigned EltNo = 0;
     for (auto Elt : TE->getElements()) {
+      // Try to simplify the element, e.g. to fold PackExpansionExprs
+      // into TypeExprs.
+      if (auto simplified = simplifyTypeExpr(Elt))
+        Elt = simplified;
+
       auto *eltTE = dyn_cast<TypeExpr>(Elt);
       if (!eltTE) return nullptr;
       TupleTypeReprElement elt;
@@ -1974,11 +1979,11 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
     return new (Ctx) TypeExpr(CompRepr);
   }
 
-  // Fold 'T...' into a pack expansion type when 'T' is a TypeExpr.
-  if (auto *operand = isPostfixEllipsisOperator(E)) {
-    if (auto *pattern = dyn_cast<TypeExpr>(operand)) {
-      auto *repr = new (Ctx) PackExpansionTypeRepr(pattern->getTypeRepr(),
-                                                   E->getLoc());
+  // Fold a pack expansion expr into a TypeExpr when the pattern is a TypeExpr.
+  if (auto *expansion = dyn_cast<PackExpansionExpr>(E)) {
+    if (auto *pattern = dyn_cast<TypeExpr>(expansion->getPatternExpr())) {
+      auto *repr = new (Ctx) PackExpansionTypeRepr(expansion->getStartLoc(),
+                                                   pattern->getTypeRepr());
       return new (Ctx) TypeExpr(repr);
     }
   }
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2258,42 +2258,28 @@ static Type validateParameterType(ParamDecl *decl) {
     break;
   }
 
-  if (auto *packExpansionRepr = dyn_cast<PackExpansionTypeRepr>(nestedRepr)) {
+  if (auto *varargTypeRepr = dyn_cast<VarargTypeRepr>(nestedRepr)) {
     // If the element is a variadic parameter, resolve the parameter type as if
     // it were in non-parameter position, since we want functions to be
     // @escaping in this case.
     options.setContext(TypeResolverContext::VariadicFunctionInput);
     options |= TypeResolutionFlags::Direct;
-    options |= TypeResolutionFlags::AllowPackReferences;
-
-    // FIXME: This duplicates code found elsewhere
-    auto *patternRepr = packExpansionRepr->getPatternType();
 
     const auto resolution =
         TypeResolution::forInterface(dc, options, unboundTyOpener,
                                      PlaceholderType::get,
                                      /*packElementOpener*/ nullptr);
-    Ty = resolution.resolveType(patternRepr);
+    Ty = resolution.resolveType(nestedRepr);
 
-    // Find the first type parameter pack and use that as the count type.
-    SmallVector<Type, 2> rootParameterPacks;
-    Ty->getTypeParameterPacks(rootParameterPacks);
+    // Monovariadic types (T...) for <T> resolve to [T].
+    Ty = VariadicSequenceType::get(Ty);
 
-    // Handle the monovariadic/polyvariadic interface type split.
-    if (!rootParameterPacks.empty()) {
-      // Polyvariadic types (T...) for <T...> resolve to pack expansions.
-      Ty = PackExpansionType::get(Ty, rootParameterPacks[0]);
-    } else {
-      // Monovariadic types (T...) for <T> resolve to [T].
-      Ty = VariadicSequenceType::get(Ty);
-
-      // Set the old-style variadic bit.
-      decl->setVariadic();
-      if (!ctx.getArrayDecl()) {
-        ctx.Diags.diagnose(decl->getTypeRepr()->getLoc(),
-                           diag::sugar_type_not_found, 0);
-        return ErrorType::get(ctx);
-      }
+    // Set the old-style variadic bit.
+    decl->setVariadic();
+    if (!ctx.getArrayDecl()) {
+      ctx.Diags.diagnose(decl->getTypeRepr()->getLoc(),
+                         diag::sugar_type_not_found, 0);
+      return ErrorType::get(ctx);
     }
   } else {
     options.setContext(TypeResolverContext::FunctionInput);
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -644,7 +644,7 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
         if (auto *specifier = dyn_cast<SpecifierTypeRepr>(typeRepr))
           typeRepr = specifier->getBase();
 
-        if (auto *packExpansion = dyn_cast<PackExpansionTypeRepr>(typeRepr)) {
+        if (auto *packExpansion = dyn_cast<VarargTypeRepr>(typeRepr)) {
           paramOptions.setContext(TypeResolverContext::VariadicFunctionInput);
         } else {
           paramOptions.setContext(TypeResolverContext::FunctionInput);
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp

Original file line number	Diff line number	Diff line change
`@@ -2002,6 +2002,11 @@ bool Traversal::visitOptionalTypeRepr(OptionalTypeRepr *T) {`
`2002`	`2002`	`bool Traversal::visitImplicitlyUnwrappedOptionalTypeRepr(ImplicitlyUnwrappedOptionalTypeRepr *T) {`
`2003`	`2003`	`return doIt(T->getBase());`
`2004`	`2004`	`}`
	`2005`	`+`
	`2006`	`+bool Traversal::visitVarargTypeRepr(VarargTypeRepr *T) {`
	`2007`	`+ return doIt(T->getElementType());`
	`2008`	`+}`
	`2009`	`+`
`2005`	`2010`	`bool Traversal::visitPackExpansionTypeRepr(PackExpansionTypeRepr *T) {`
`2006`	`2011`	`return doIt(T->getPatternType());`
`2007`	`2012`	`}`
Original file line number	Diff line number	Diff line change
`@@ -466,10 +466,10 @@ void ProtocolTypeRepr_create(void ctx, void baseType, void protoLoc) {`
`466`	`466`	`return new (Context) ProtocolTypeRepr((TypeRepr *)baseType, protocolLoc);`
`467`	`467`	`}`
`468`	`468`
`469`		`-void PackExpansionTypeRepr_create(void ctx, void base, void ellipsisLoc) {`
	`469`	`+void PackExpansionTypeRepr_create(void ctx, void base, void repeatLoc) {`
`470`	`470`	`ASTContext &Context = static_cast<ASTContext >(ctx);`
`471`	`471`	`return new (Context) PackExpansionTypeRepr(`
`472`		`- (TypeRepr *)base, getSourceLocFromPointer(ellipsisLoc));`
	`472`	`+ getSourceLocFromPointer(repeatLoc), (TypeRepr *)base);`
`473`	`473`	`}`
`474`	`474`
`475`	`475`	`void TupleTypeRepr_create(void ctx, BridgedArrayRef elements, void *lParenLoc,`
Original file line number	Diff line number	Diff line change
`@@ -118,8 +118,8 @@ extension ASTGenVisitor {`
`118`	`118`
`119`	`119`	`public func visit(_ node: PackExpansionTypeSyntax) -> ASTNode {`
`120`	`120`	`let base = visit(node.patternType).rawValue`
`121`		`- let ellipsisLoc = self.base.advanced(by: node.ellipsis.position.utf8Offset).raw`
`122`		`- return .type(PackExpansionTypeRepr_create(self.ctx, base, ellipsisLoc))`
	`121`	`+ let repeatLoc = self.base.advanced(by: node.repeatKeyword.position.utf8Offset).raw`
	`122`	`+ return .type(PackExpansionTypeRepr_create(self.ctx, base, repeatLoc))`
`123`	`123`	`}`
`124`	`124`
`125`	`125`	`public func visit(_ node: TupleTypeSyntax) -> ASTNode {`