[Syntax] function-parameter-list is now a SyntaxCollection

Removes some code duplication.

include/swift/Syntax/DeclSyntax.h

@@ -22,6 +22,7 @@
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/RawSyntax.h"
 #include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/SyntaxCollection.h"
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
 #include "swift/Syntax/TypeSyntax.h"
@@ -420,8 +421,6 @@ class FunctionParameterSyntax final : public Syntax {
   friend class SyntaxData;
   friend class FunctionParameterSyntaxData;
 
-  using DataType = FunctionParameterSyntaxData;
-
   enum class Cursor : CursorIndex {
     ExternalName,
     LocalName,
@@ -433,10 +432,13 @@ class FunctionParameterSyntax final : public Syntax {
     TrailingComma,
   };
 
-  FunctionParameterSyntax(const RC<SyntaxData> Root,
-                          const DataType *Data);
-
 public:
+  using DataType = FunctionParameterSyntaxData;
+  static constexpr SyntaxKind Kind = SyntaxKind::FunctionParameter;
+
+  FunctionParameterSyntax(const RC<SyntaxData> Root, const DataType *Data)
+    : Syntax(Root, Data) {}
+
   /// Get the external name of the parameter, if there is one.
   RC<TokenSyntax> getExternalName() const;
 
@@ -498,27 +500,23 @@ public:
 
 #pragma mark - function-parameter-list Data
 
-class FunctionParameterListSyntaxData final : public SyntaxData {
-
-  std::vector<RC<FunctionParameterSyntaxData>> CachedParameters;
-
-public:
-  static bool classof(const SyntaxData *SD) {
-    return SD->getKind() == SyntaxKind::FunctionParameterList;
-  }
-};
+using FunctionParameterListSyntaxData = SyntaxCollectionData<SyntaxKind::FunctionParameterList, FunctionParameterSyntax>;
 
 #pragma mark - function-parameter-list API
 
 /// parameter-list -> parameteter | parameter ',' parameter-list
-class FunctionParameterListSyntax final : public Syntax {
-  friend struct SyntaxBuilder;
+class FunctionParameterListSyntax final : public
+  SyntaxCollection<SyntaxKind::FunctionParameterList, FunctionParameterSyntax> {
+  friend struct SyntaxFactory;
   friend class Syntax;
   friend class SyntaxData;
-  friend class FunctionParameterListSyntaxData;
 
   using DataType = FunctionParameterListSyntaxData;
 
+  FunctionParameterListSyntax(const RC<SyntaxData> Root,
+                              const DataType *Data)
+    : SyntaxCollection(Root, Data) {}
+
 public:
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::FunctionParameterList;

lib/Syntax/DeclSyntax.cpp

@@ -421,10 +421,6 @@ RC<FunctionParameterSyntaxData> FunctionParameterSyntaxData::makeBlank() {
 
 #pragma mark - function-parameter API
 
-FunctionParameterSyntax::FunctionParameterSyntax(const RC<SyntaxData> Root,
-                                                 const DataType *Data)
-  : Syntax(Root, Data) {}
-
 RC<TokenSyntax> FunctionParameterSyntax::getExternalName() const {
   return cast<TokenSyntax>(getRaw()->getChild(Cursor::ExternalName));
 }

lib/Syntax/SyntaxFactory.cpp

@@ -126,6 +126,23 @@ FunctionParameterSyntax SyntaxFactory::makeBlankFunctionParameter() {
   return { Data, Data.get() };
 }
 
+FunctionParameterListSyntax SyntaxFactory::makeFunctionParameterList(const std::vector<FunctionParameterSyntax> &Parameters) {
+  RawSyntax::LayoutList Layout;
+  for (auto Param : Parameters) {
+    Layout.push_back(Param.getRaw());
+  }
+
+  auto Raw = RawSyntax::make(SyntaxKind::FunctionParameterList, Layout,
+                             SourcePresence::Present);
+  auto Data = FunctionParameterListSyntaxData::make(Raw);
+  return { Data, Data.get() };
+}
+
+FunctionParameterListSyntax SyntaxFactory::makeBlankFunctionParameterList() {
+  auto Data = FunctionParameterListSyntaxData::makeBlank();
+  return { Data, Data.get() };
+}
+
 #pragma mark - Statements
 
 CodeBlockStmtSyntax

unittests/Syntax/DeclSyntaxTests.cpp

@@ -156,7 +156,7 @@ FunctionParameterSyntax getCannedFunctionParameter() {
   auto Sign = SyntaxFactory::makePrefixOpereator("-", {});
   auto OneDigits = SyntaxFactory::makeIntegerLiteralToken("1", {}, {});
   auto One = SyntaxFactory::makeIntegerLiteralExpr(Sign, OneDigits);
-  auto Comma = SyntaxFactory::makeCommaToken({}, {});
+  auto Comma = SyntaxFactory::makeCommaToken({}, Trivia::spaces(1));
 
   return SyntaxFactory::makeFunctionParameter(ExternalName, LocalName, Colon,
                                               Int, NoEllipsis, Equal, One,
@@ -168,7 +168,7 @@ TEST(DeclSyntaxTests, FunctionParameterMakeAPIs) {
     SmallString<48> Scratch;
     llvm::raw_svector_ostream OS(Scratch);
     getCannedFunctionParameter().print(OS);
-    ASSERT_EQ(OS.str().str(), "with radius: Int = -1,");
+    ASSERT_EQ(OS.str().str(), "with radius: Int = -1, ");
   }
   {
     SmallString<48> Scratch;
@@ -258,22 +258,28 @@ TEST(DeclSyntaxTests, FunctionParameterWithAPIs) {
       .withTypeSyntax(llvm::None)
       .withDefaultValue(llvm::None)
       .print(OS);
-    ASSERT_EQ(OS.str().str(), "with radius: = ,");
+    ASSERT_EQ(OS.str().str(), "with radius: = , ");
   }
 }
 
 #pragma mark - parameter-list
 
 TEST(DeclSyntaxTests, FunctionParameterListMakeAPIs) {
-
-}
-
-TEST(DeclSyntaxTests, FunctionParameterListGetAPIs) {
-
-}
-
-TEST(DeclSyntaxTests, FunctionParameterListWithAPIs) {
-  
+  {
+    SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    SyntaxFactory::makeBlankFunctionParameterList().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+  {
+    SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+    auto Param = getCannedFunctionParameter();
+    std::vector<FunctionParameterSyntax> Params { Param, Param, Param };
+    SyntaxFactory::makeFunctionParameterList(Params).print(OS);
+    ASSERT_EQ(OS.str().str(),
+      "with radius: Int = -1, with radius: Int = -1, with radius: Int = -1, ");
+  }
 }
 
 #pragma mark - function-signature