[Syntax] Refactor Tuple Type Syntax (#8254)

* Refactor Tuple Type Syntax

This patch:

- Refactors TypeArgumentListSyntax and
  TypeArgumentListSyntaxData to use the SyntaxCollection and
  SyntaxCollectionData APIs.
- Refactors TupleTypeElementSyntax to own its trailing comma, and
  updates the tests accordingly.
- Provides an infrastructure for promoting types to use
  the SyntaxCollection APIs

* Addressed comments.

* Renamed makeBlankTypeArgumentList()

* Update makeTupleType

* Changed makeTupleType to take an element list.

* Updated comment.

* Improved API for creating TupleTypeElementListSyntax'es

* Added round-trip test

* Removed last TypeArgumentList holdovers.

* Fixed round-trip test invocation

Author: harlanhaskins

include/swift/Syntax/RawSyntax.h

@@ -150,6 +150,7 @@ class AbsolutePosition {
 enum class SyntaxKind {
   Token,
 #define SYNTAX(Id, Parent) Id,
+#define SYNTAX_COLLECTION(Id, Element) Id,
 #define MISSING_SYNTAX(Id, Parent) Id,
 #define SYNTAX_RANGE(Id, First, Last) First_##Id = First, Last_##Id = Last,
 #include "swift/Syntax/SyntaxKinds.def"

include/swift/Syntax/Rewriter.h

@@ -40,6 +40,7 @@ struct SyntaxRewriter {
   virtual Id##Syntax rewrite##Id(Id##Syntax Node) { \
     return Node; \
   }
+#define SYNTAX_COLLECTION(Id, Element) SYNTAX(Id, {})
 #include "swift/Syntax/SyntaxKinds.def"
   virtual ~SyntaxRewriter() = default;
 };

include/swift/Syntax/SyntaxCollection.h

@@ -54,6 +54,18 @@ class SyntaxCollection : public Syntax {
   friend class Syntax;
   using DataType = SyntaxCollectionData<CollectionKind, Element>;
 
+private:
+  static RC<DataType>
+  makeData(std::vector<Element> &Elements) {
+    RawSyntax::LayoutList List;
+    for (auto &Elt : Elements) {
+      List.push_back(Elt.getRaw());
+    }
+    auto Raw = RawSyntax::make(CollectionKind, List,
+                               SourcePresence::Present);
+    return DataType::make(Raw);
+  }
+
 protected:
   SyntaxCollection(const RC<SyntaxData> Root, const DataType *Data)
     : Syntax(Root, Data) {}
@@ -189,6 +201,12 @@ class SyntaxCollection : public Syntax {
   }
 };
 
+#define SYNTAX(Id, Parent)
+#define SYNTAX_COLLECTION(Id, Element) \
+  class Element;                       \
+  using Id##Syntax = SyntaxCollection<SyntaxKind::Id, Element>;
+#include "swift/Syntax/SyntaxKinds.def"
+
 } // end namespace syntax
 } // end namespace swift
 

include/swift/Syntax/SyntaxCollectionData.h

@@ -30,12 +30,6 @@ class SyntaxCollectionData : public SyntaxData {
   friend class SyntaxData;
   friend class FunctionCallExprSyntaxBuilder;
 
-  SyntaxCollectionData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
-                       CursorIndex IndexInParent = 0)
-      : SyntaxData(Raw, Parent, IndexInParent),
-        CachedElements(Raw->Layout.size(), nullptr) {
-    assert(Raw->Kind == CollectionKind);
-  }
 
   static RC<SyntaxCollectionData<CollectionKind, ElementType>>
   make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
@@ -53,12 +47,26 @@ class SyntaxCollectionData : public SyntaxData {
     return make(Raw);
   }
 
+protected:
+  SyntaxCollectionData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+                       CursorIndex IndexInParent = 0)
+  : SyntaxData(Raw, Parent, IndexInParent),
+  CachedElements(Raw->Layout.size(), nullptr) {
+      assert(Raw->Kind == CollectionKind);
+  }
+
 public:
   static bool classof(const SyntaxData *SD) {
     return SD->getKind() == CollectionKind;
   }
 };
 
+#define SYNTAX(Id, Parent)
+#define SYNTAX_COLLECTION(Id, Element) \
+  class Element;                       \
+  using Id##SyntaxData = SyntaxCollectionData<SyntaxKind::Id, Element>;
+#include "swift/Syntax/SyntaxKinds.def"
+
 } // end namespace syntax
 } // end namespace swift
 

include/swift/Syntax/SyntaxFactory.h

@@ -474,12 +474,27 @@ struct SyntaxFactory {
   /// Make a bare "()" void tuple type
   static TupleTypeSyntax makeVoidTupleType();
 
+  /// Make a tuple type from a type element list and the provided left/right
+  /// paren tokens.
+  static TupleTypeSyntax
+  makeTupleType(RC<TokenSyntax> LParen,
+                TupleTypeElementListSyntax Elements,
+                RC<TokenSyntax> RParen);
+
   /// Make a tuple type element of the form 'Name: ElementType'
   static TupleTypeElementSyntax
-  makeTupleTypeElement(RC<TokenSyntax> Name, TypeSyntax ElementType);
+  makeTupleTypeElement(RC<TokenSyntax> Name, RC<TokenSyntax> Colon,
+                       TypeSyntax ElementType,
+                       llvm::Optional<RC<TokenSyntax>> MaybeComma = llvm::None);
 
   /// Make a tuple type element without a label.
-  static TupleTypeElementSyntax makeTupleTypeElement(TypeSyntax ElementType);
+  static TupleTypeElementSyntax
+  makeTupleTypeElement(TypeSyntax ElementType,
+                       llvm::Optional<RC<TokenSyntax>> MaybeComma = llvm::None);
+
+  /// Make a tuple type element list.
+  static TupleTypeElementListSyntax
+  makeTupleTypeElementList(std::vector<TupleTypeElementSyntax> ElementTypes);
 
 #pragma mark - optional-type
 
@@ -564,17 +579,17 @@ struct SyntaxFactory {
   static FunctionTypeSyntax
   makeFunctionType(TypeAttributesSyntax TypeAttributes,
                    RC<TokenSyntax> LeftParen,
-                   TypeArgumentListSyntax ArgumentList,
+                   TupleTypeElementListSyntax ArgumentList,
                    RC<TokenSyntax> RightParen, RC<TokenSyntax> ThrowsOrRethrows,
                    RC<TokenSyntax> Arrow, TypeSyntax ReturnType);
 
   /// Make a function type with all elements marked as missing.
   static FunctionTypeSyntax makeBlankFunctionType();
 
-#pragma mark - type-argument-list
+#pragma mark - tuple-type-element-list
 
   /// Make a list of type arguments with all elements marked as missing.
-  static TypeArgumentListSyntax makeBlankTypeArgumentList();
+  static TupleTypeElementListSyntax makeBlankTupleTypeElementList();
 
 #pragma mark - Generics
 

include/swift/Syntax/SyntaxKinds.def

@@ -32,6 +32,10 @@
 #define MISSING_SYNTAX(Id, Parent)
 #endif
 
+#ifndef SYNTAX_COLLECTION
+#define SYNTAX_COLLECTION(Id, Element)
+#endif
+
 SYNTAX(Unknown, Syntax)
 
 // Decls
@@ -56,7 +60,6 @@ SYNTAX(GenericArgumentList, Syntax)
 ABSTRACT_SYNTAX(GenericRequirementSyntax, Syntax)
   SYNTAX(ConformanceRequirement, GenericRequirementSyntax)
   SYNTAX(SameTypeRequirement, GenericRequirementSyntax)
-SYNTAX(TypeArgumentList, Syntax)
 
 // Types
 ABSTRACT_SYNTAX(TypeSyntax, Syntax)
@@ -106,6 +109,9 @@ SYNTAX(FunctionParameter, Syntax)
 SYNTAX(DeclModifier, Syntax)
 SYNTAX(DeclModifierList, Syntax)
 
+SYNTAX_COLLECTION(TupleTypeElementList, TupleTypeElementSyntax)
+
+#undef SYNTAX_COLLECTION
 #undef ABSTRACT_SYNTAX
 #undef DECL
 #undef STMT

include/swift/Syntax/TypeSyntax.h

@@ -315,27 +315,6 @@ class TypeIdentifierSyntax final : public TypeSyntax {
   }
 };
 
-#pragma mark - type-argument-list Data
-
-class TypeArgumentListSyntaxData final : public SyntaxData {
-  friend class SyntaxData;
-  friend struct SyntaxFactory;
-
-  TypeArgumentListSyntaxData(RC<RawSyntax> Raw,
-                             const SyntaxData *Parent = nullptr,
-                             CursorIndex IndexInParent = 0);
-
-  static RC<TypeArgumentListSyntaxData> make(RC<RawSyntax> Raw,
-                                             const SyntaxData *Parent = nullptr,
-                                             CursorIndex IndexInParent = 0);
-  static RC<TypeArgumentListSyntaxData> makeBlank();
-
-public:
-  static bool classof(const SyntaxData *S) {
-    return S->getKind() == SyntaxKind::TypeArgumentList;
-  }
-};
-
 #pragma mark - tuple-type-element Data
 
 class TupleTypeElementSyntaxData final : public SyntaxData {
@@ -366,19 +345,20 @@ class TupleTypeElementSyntax final : public Syntax {
   friend class TupleTypeElementSyntaxData;
   friend class SyntaxData;
 
-  using DataType = TupleTypeElementSyntaxData;
-
   enum class Cursor : CursorIndex {
     Label,
     ColonToken,
     Attributes,
     InoutToken,
     Type,
+    CommaToken,
   };
 
   TupleTypeElementSyntax(RC<SyntaxData> Root,
                          const TupleTypeElementSyntaxData *Data);
 public:
+  using DataType = TupleTypeElementSyntaxData;
+  
   /// Return the label of the tuple type element.
   RC<TokenSyntax> getLabel() const;
 
@@ -393,6 +373,14 @@ class TupleTypeElementSyntax final : public Syntax {
   TupleTypeElementSyntax
   withColonToken(RC<TokenSyntax> NewColonToken) const;
 
+  /// Return the comma token of the tuple type element.
+  RC<TokenSyntax> getCommaToken() const;
+
+  /// Return a new named tuple type element with a comma token replacement
+  /// using the specified leading and trailing trivia.
+  TupleTypeElementSyntax
+  withCommaToken(RC<TokenSyntax> NewCommaToken) const;
+
   /// Return the type attributes for the tuple type element.
   TypeAttributesSyntax getTypeAttributes() const;
 
@@ -415,33 +403,7 @@ class TupleTypeElementSyntax final : public Syntax {
     return S->getKind() == SyntaxKind::TupleTypeElement;
   }
 };
-
-
-#pragma mark - type-argument-list API
-
-/// type-argument-list
-///   -> function-type-argument
-///    | function-type-argument ',' function-type-argument-list
-class TypeArgumentListSyntax final : public Syntax {
-  friend struct SyntaxFactory;
-  friend class SyntaxData;
-
-  using DataType = TypeArgumentListSyntaxData;
-
-  TypeArgumentListSyntax(RC<SyntaxData> Root,
-                         const TypeArgumentListSyntaxData *Data);
-
-public:
-  // TODO: TODO: getType
-  TypeArgumentListSyntax
-  addType(llvm::Optional<RC<TokenSyntax>> MaybeComma,
-          TupleTypeElementSyntax NewTypeArgument) const;
-
-  static bool classof(const Syntax *S) {
-    return S->getKind() == SyntaxKind::TypeArgumentList;
-  }
-};
-
+  
 #pragma mark - tuple-type Data
 
 class TupleTypeSyntaxData final : public TypeSyntaxData {
@@ -476,7 +438,7 @@ class TupleTypeSyntax final : public TypeSyntax {
 
   enum class Cursor : CursorIndex {
     LeftParenToken,
-    TypeArgumentList,
+    TypeElementList,
     RightParenToken,
   };
 
@@ -488,11 +450,11 @@ class TupleTypeSyntax final : public TypeSyntax {
   TupleTypeSyntax withLeftParen(RC<TokenSyntax> NewLeftParen) const;
 
   /// Get the type argument list inside the tuple type syntax.
-  TypeArgumentListSyntax getTypeArgumentList() const;
+  TupleTypeElementListSyntax getTypeElementList() const;
 
   /// Return a new tuple type syntax with the given type argument list.
   TupleTypeSyntax
-  withTypeArgumentList(TypeArgumentListSyntax NewTypeArgumentList) const;
+  withTypeElementList(TupleTypeElementListSyntax NewTypeElementList) const;
 
   /// Return the right paren ')' token surrounding the tuple type syntax.
   RC<TokenSyntax> getRightParen() const;
@@ -519,8 +481,7 @@ class TupleTypeSyntaxBuilder final {
 
   /// Add an element type to the eventual tuple type syntax.
   TupleTypeSyntaxBuilder &
-  addElementTypeSyntax(llvm::Optional<RC<TokenSyntax>> MaybeComma,
-                       TupleTypeElementSyntax ElementTypeSyntax);
+  addElementTypeSyntax(TupleTypeElementSyntax ElementTypeSyntax);
 
   /// Use the given left paren '(' token when building the tuple type syntax.
   TupleTypeSyntaxBuilder &useRightParen(RC<TokenSyntax> RightParen);
@@ -973,13 +934,13 @@ class FunctionTypeSyntax final : public TypeSyntax {
                   FunctionTypeArgumentSyntax NewArgument) const;
 
   /// Return the type arguments list for this function type syntax.
-  TypeArgumentListSyntax getTypeArgumentList() const;
+  TupleTypeElementListSyntax getTypeElementList() const;
 
   /// Return a new function type with the given type argument list.
   ///
   /// This replaces all of the argument types.
   FunctionTypeSyntax
-  withTypeArgumentList(TypeArgumentListSyntax NewArgumentList) const;
+  withTypeElementList(TupleTypeElementListSyntax NewArgumentList) const;
 
   /// Return the right parenthesis ')' token surrounding the argument type.
   RC<TokenSyntax> getRightArgumentsParen() const;

lib/Syntax/GenericSyntax.cpp

@@ -374,7 +374,7 @@ GenericArgumentClauseSyntaxData::makeBlank() {
   auto Raw = RawSyntax::make(SyntaxKind::GenericArgumentClause,
                              {
                                TokenSyntax::missingToken(tok::l_angle, "<"),
-                               RawSyntax::missing(SyntaxKind::TypeArgumentList),
+                               RawSyntax::missing(SyntaxKind::GenericArgumentList),
                                TokenSyntax::missingToken(tok::r_angle, ">"),
                              },
                              SourcePresence::Present);
@@ -439,7 +439,7 @@ useRightAngleBracket(RC<TokenSyntax> RightAngle) {
 
 
 GenericArgumentClauseSyntax GenericArgumentClauseBuilder::build() const {
-  auto ArgListRaw = RawSyntax::make(SyntaxKind::TypeArgumentList,
+  auto ArgListRaw = RawSyntax::make(SyntaxKind::GenericParameterList,
                                     ArgumentListLayout,
                                     SourcePresence::Present);
   auto Raw = RawSyntax::make(SyntaxKind::GenericArgumentClause,

lib/Syntax/RawSyntax.cpp

@@ -28,6 +28,7 @@ void dumpSyntaxKind(llvm::raw_ostream &OS, const SyntaxKind Kind) {
     OS << #Id;                                                                 \
     break;
 #define MISSING_SYNTAX(Id, Parent) SYNTAX(Id, Parent)
+#define SYNTAX_COLLECTION(Id, Element) SYNTAX(Id, {})
 #include "swift/Syntax/SyntaxKinds.def"
   case SyntaxKind::Token: OS << "Token"; break;
   }

lib/Syntax/SyntaxData.cpp

@@ -41,6 +41,8 @@ RC<SyntaxData> SyntaxData::makeDataFromRaw(RC<RawSyntax> Raw,
   case SyntaxKind::Id: \
     return ParentType##Data::make(Raw, Parent, IndexInParent);
 
+#define SYNTAX_COLLECTION(Id, Element) SYNTAX(Id, {})
+
 #include "swift/Syntax/SyntaxKinds.def"
   case SyntaxKind::Token:
     llvm_unreachable("Can't make a SyntaxData from a Token!");