[Variadic Generics] fix diagnostics dangling reference and fixits for parameter pack syntax change: T... -> each T

Author: sophiapoirier

CMakeLists.txt

@@ -45,7 +45,7 @@ endif()
 
 ENABLE_LANGUAGE(C)
 
-# Use C++14.
+# Use C++17.
 set(CMAKE_CXX_STANDARD 17 CACHE STRING "C++ standard to conform to")
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 set(CMAKE_CXX_EXTENSIONS NO)

lib/Parse/ParseDecl.cpp

@@ -6375,6 +6375,14 @@ ParserResult<TypeDecl> Parser::parseDeclAssociatedType(Parser::ParseDeclOptions
     AssociatedTypeLoc = consumeToken(tok::kw_associatedtype);
   }
 
+  // Reject variadic associated types with a specific error.
+  if (Context.LangOpts.hasFeature(Feature::VariadicGenerics) &&
+      Tok.isContextualKeyword("each")) {
+    const auto EachLoc = consumeToken();
+    diagnose(EachLoc, diag::associatedtype_cannot_be_variadic)
+        .fixItRemoveChars(EachLoc, Tok.getLoc());
+  }
+
   Status = parseIdentifierDeclName(
       *this, Id, IdLoc, "associatedtype",
       [](const Token &next) { return next.isAny(tok::colon, tok::equal); });
@@ -6392,12 +6400,13 @@ ParserResult<TypeDecl> Parser::parseDeclAssociatedType(Parser::ParseDeclOptions
     }
   }
 
-  // Reject variadic associated types with a specific error.
+  // Reject (early syntax) variadic associated types with a specific error.
   if (Context.LangOpts.hasFeature(Feature::VariadicGenerics) &&
       startsWithEllipsis(Tok)) {
-    auto Ellipsis = consumeStartingEllipsis();
-    diagnose(Ellipsis, diag::associatedtype_cannot_be_variadic)
-      .fixItRemoveChars(Ellipsis, Tok.getLoc());
+    const auto EllipsisLoc = consumeStartingEllipsis();
+    const auto EllipsisEnd = Lexer::getLocForEndOfToken(SourceMgr, EllipsisLoc);
+    diagnose(EllipsisLoc, diag::associatedtype_cannot_be_variadic)
+        .fixItRemoveChars(EllipsisLoc, EllipsisEnd);
   }
 
   // Parse optional inheritance clause.

lib/Parse/ParseGeneric.cpp

@@ -80,13 +80,15 @@ Parser::parseGenericParametersBeforeWhere(SourceLoc LAngleLoc,
     // 'T...'.
     if (Context.LangOpts.hasFeature(Feature::VariadicGenerics) &&
         startsWithEllipsis(Tok)) {
+      const auto EllipsisLoc = consumeStartingEllipsis();
+      // TODO: token length hardcoded because calculation for ellipsis
+      // incorrectly includes '>' if one follows (as can occur in this parse).
       constexpr int EllipsisLength = 3;
-      const SourceRange EllipsisRange(
-          Tok.getLoc(), Tok.getLoc().getAdvancedLoc(EllipsisLength));
-      auto &Diagnostic = diagnose(Tok, diag::type_parameter_pack_ellipsis)
-                             .fixItRemove(EllipsisRange);
+      const auto EllipsisEnd = EllipsisLoc.getAdvancedLoc(EllipsisLength);
+      auto Diag = diagnose(Tok, diag::type_parameter_pack_ellipsis);
+      Diag.fixItRemoveChars(EllipsisLoc, EllipsisEnd);
       if (!EachLoc.isValid()) {
-        Diagnostic.fixItInsert(NameLoc, "each");
+        Diag.fixItInsert(NameLoc, "each ");
       }
       Result.setIsParseError();
       break;

test/Parse/type_parameter_packs.swift

@@ -5,10 +5,14 @@
 protocol P {}
 
 protocol P1 {
-  associatedtype A... // expected-error {{associated types cannot be variadic}}
-  associatedtype B<U>...
-  // expected-error@-1 {{associated types cannot be variadic}}
-  // expected-error@-2 {{associated types must not have a generic parameter list}}
+  associatedtype each A // expected-error {{associated types cannot be variadic}}{{18-23=}}
+  associatedtype each B<U>
+  // expected-error@-1 {{associated types cannot be variadic}}{{18-23=}}
+  // expected-error@-2 {{associated types must not have a generic parameter list}}{{24-27=}}
+  associatedtype C... // expected-error {{associated types cannot be variadic}}{{19-22=}}
+  associatedtype D<U>...
+  // expected-error@-1 {{associated types cannot be variadic}}{{22-25=}}
+  // expected-error@-2 {{associated types must not have a generic parameter list}}{{19-22=}}
 }
 
 typealias Alias<each T> = (repeat each T)
@@ -32,3 +36,10 @@ func quux<each T: P>(_ x: repeat each T) {}
 func foobar<T, U, each V>(x: T, y: U, z: repeat each V) { }
 func foobaz<T, each U, V>(x: T, y: repeat each U, z: V) { }
 func fooqux<each T, each U, each V>(x: repeat each T, y: repeat each U, z: repeat each V) { }
+
+func ellipsis<T...>(_ x: repeat each T) {}
+// expected-error@-1 {{ellipsis operator cannot be used with a type parameter pack}}{{16-19=}}{{15-15=each }}
+// expected-error@-2 {{cannot find type 'T' in scope}}
+func eachEllipsis<each T...>(_ x: repeat each T) {}
+// expected-error@-1 {{ellipsis operator cannot be used with a type parameter pack}}{{25-28=}}
+// expected-error@-2 {{cannot find type 'T' in scope}}