[ASTGen] Handle variadic parameters in functions and function types

There is a modeling difference between the swift-syntax tree and the
C++ type representation (TypeRepr) that is a little odd here, so we
end up parsing the ellipsis on the C++ side rather than looking "up"
the syntax tree to find it.

Author: DougGregor

include/swift/AST/CASTBridging.h

@@ -274,6 +274,7 @@ void *MetatypeTypeRepr_create(void *ctx, void *baseType, void *typeLoc);
 void *ProtocolTypeRepr_create(void *ctx, void *baseType, void *protoLoc);
 void *AttributedTypeSpecifierRepr_create(
     void *ctx, void *base, BridgedAttributedTypeSpecifier specifier, void *specifierLoc);
+void *VarargTypeRepr_create(void *ctx, void *base, void *ellipsisLocPtr);
 void *PackExpansionTypeRepr_create(void *ctx, void *base, void *repeatLoc);
 void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
                            void *rParenLoc);

lib/AST/CASTBridging.cpp

@@ -514,6 +514,13 @@ void *AttributedTypeSpecifierRepr_create(
   }
 }
 
+void *VarargTypeRepr_create(void *ctx, void *base, void *ellipsisLocPtr) {
+  ASTContext &Context = *static_cast<ASTContext *>(ctx);
+  SourceLoc ellipsisLoc = getSourceLocFromPointer(ellipsisLocPtr);
+  TypeRepr *baseType = (TypeRepr *)base;
+  return new (Context) VarargTypeRepr(baseType, ellipsisLoc);
+}
+
 void *TupleTypeRepr_create(void *ctx, BridgedArrayRef elements, void *lParenLoc,
                            void *rParenLoc) {
   ASTContext &Context = *static_cast<ASTContext *>(ctx);

lib/ASTGen/Sources/ASTGen/Macros.swift

@@ -637,7 +637,7 @@ func findSyntaxNodeInSourceFile<Node: SyntaxProtocol>(
     while let parentSyntax = resultSyntax.parent {
       guard let typedParent = parentSyntax.as(type),
             typedParent.position == resultSyntax.position else {
-        break;
+        break
       }
 
       resultSyntax = typedParent

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -213,7 +213,13 @@ extension ASTGenVisitor {
         self.base.advanced(by: $0.position.utf8Offset).raw
       }
       let colonLoc = element.colon.map { self.base.advanced(by: $0.position.utf8Offset).raw }
-      let type = visit(element.type).rawValue
+
+      var type = visit(element.type).rawValue
+      if let ellipsis = element.ellipsis {
+        let ellipsisLoc = self.base.advanced(by: ellipsis.positionAfterSkippingLeadingTrivia.utf8Offset).raw
+        type = VarargTypeRepr_create(self.ctx, type, ellipsisLoc)
+      }
+
       let trailingCommaLoc = element.trailingComma.map {
         self.base.advanced(by: $0.position.utf8Offset).raw
       }

lib/Parse/ParseType.cpp

@@ -599,8 +599,21 @@ ParserResult<TypeRepr> Parser::parseType(
             CurDeclContext, &Context, &endLocPtr);
         return std::make_pair(typeRepr, endLocPtr);
       });
-  if (astGenResult.isNonNull())
+  if (astGenResult.isNonNull()) {
+    // Note: there is a representational difference between the swift-syntax
+    // tree and the C++ parser tree regarding variadic parameters. In the
+    // swift-syntax tree, the ellipsis is part of the parameter declaration.
+    // In the C++ parser tree, the ellipsis is part of the type. Account for
+    // this difference by consuming the ellipsis here.
+    if (Tok.isEllipsis()) {
+      Tok.setKind(tok::ellipsis);
+      SourceLoc ellipsisLoc = consumeToken();
+      return makeParserResult(astGenResult,
+          new (Context) VarargTypeRepr(astGenResult.get(), ellipsisLoc));
+    }
+
     return astGenResult;
+  }
   #endif
 
   // Parse pack expansion 'repeat T'

test/ASTGen/types.swift

@@ -11,3 +11,13 @@ func test7(_ b: inout Bool) {
 struct X { struct `Protocol` { } }
 
 func test10(_: X.`Protocol`) { }
+
+func test11(_: Int...) { }
+func test11a() {
+  test11(1, 2, 3, 4, 5)
+}
+
+typealias VAFunc = (Int, Int...) -> Int
+func testVAFunc(a: Int, f: VAFunc) {
+  _ = f(a, a, a, a, a)
+}