Correct the Syntax of Primary Associated Types

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1255,6 +1255,12 @@ extension SyntaxNode {
     return ConformanceRequirementSyntax(asSyntaxData)
   }
 
+  public var isPrimaryAssociatedTypeClause: Bool { return raw.kind == .primaryAssociatedTypeClause }
+  public var asPrimaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? {
+    guard isPrimaryAssociatedTypeClause else { return nil }
+    return PrimaryAssociatedTypeClauseSyntax(asSyntaxData)
+  }
+
   public var isSimpleTypeIdentifier: Bool { return raw.kind == .simpleTypeIdentifier }
   public var asSimpleTypeIdentifier: SimpleTypeIdentifierSyntax? {
     guard isSimpleTypeIdentifier else { return nil }
@@ -1917,6 +1923,8 @@ extension Syntax {
       return node
     case .conformanceRequirement(let node):
       return node
+    case .primaryAssociatedTypeClause(let node):
+      return node
     case .simpleTypeIdentifier(let node):
       return node
     case .memberTypeIdentifier(let node):

Sources/SwiftSyntax/gyb_generated/SyntaxAnyVisitor.swift

@@ -1506,6 +1506,13 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
   override open func visitPost(_ node: ConformanceRequirementSyntax) {
     visitAnyPost(node._syntaxNode)
   }
+  override open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: PrimaryAssociatedTypeClauseSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
   override open func visit(_ node: SimpleTypeIdentifierSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -4207,7 +4207,7 @@ extension StructDeclSyntax {
 
 public struct ProtocolDeclSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 7)
+    Array<RawSyntax?>(repeating: nil, count: 8)
 
   internal init() {}
 
@@ -4243,6 +4243,11 @@ public struct ProtocolDeclSyntaxBuilder {
     layout[idx] = node.raw
   }
 
+  public mutating func usePrimaryAssociatedTypeClause(_ node: PrimaryAssociatedTypeClauseSyntax) {
+    let idx = ProtocolDeclSyntax.Cursor.primaryAssociatedTypeClause.rawValue
+    layout[idx] = node.raw
+  }
+
   public mutating func useInheritanceClause(_ node: TypeInheritanceClauseSyntax) {
     let idx = ProtocolDeclSyntax.Cursor.inheritanceClause.rawValue
     layout[idx] = node.raw
@@ -4265,8 +4270,8 @@ public struct ProtocolDeclSyntaxBuilder {
     if (layout[3] == nil) {
       layout[3] = RawSyntax.missingToken(TokenKind.identifier(""))
     }
-    if (layout[6] == nil) {
-      layout[6] = RawSyntax.missing(SyntaxKind.memberDeclBlock)
+    if (layout[7] == nil) {
+      layout[7] = RawSyntax.missing(SyntaxKind.memberDeclBlock)
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .protocolDecl,
@@ -9249,6 +9254,66 @@ extension ConformanceRequirementSyntax {
   }
 }
 
+public struct PrimaryAssociatedTypeClauseSyntaxBuilder {
+  private var layout =
+    Array<RawSyntax?>(repeating: nil, count: 3)
+
+  internal init() {}
+
+  public mutating func useLeftAngleBracket(_ node: TokenSyntax) {
+    let idx = PrimaryAssociatedTypeClauseSyntax.Cursor.leftAngleBracket.rawValue
+    layout[idx] = node.raw
+  }
+
+  public mutating func addPrimaryAssociatedType(_ elt: PrimaryAssociatedTypeSyntax) {
+    let idx = PrimaryAssociatedTypeClauseSyntax.Cursor.primaryAssociatedTypeList.rawValue
+    if let list = layout[idx] {
+      layout[idx] = list.appending(elt.raw)
+    } else {
+      layout[idx] = RawSyntax.create(kind: SyntaxKind.primaryAssociatedTypeList,
+        layout: [elt.raw], length: elt.raw.totalLength,
+        presence: SourcePresence.present)
+    }
+  }
+
+  public mutating func useRightAngleBracket(_ node: TokenSyntax) {
+    let idx = PrimaryAssociatedTypeClauseSyntax.Cursor.rightAngleBracket.rawValue
+    layout[idx] = node.raw
+  }
+
+  internal mutating func buildData() -> SyntaxData {
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.leftAngle)
+    }
+    if (layout[1] == nil) {
+      layout[1] = RawSyntax.missing(SyntaxKind.primaryAssociatedTypeList)
+    }
+    if (layout[2] == nil) {
+      layout[2] = RawSyntax.missingToken(TokenKind.rightAngle)
+    }
+
+    return .forRoot(RawSyntax.createAndCalcLength(kind: .primaryAssociatedTypeClause,
+      layout: layout, presence: .present))
+  }
+}
+
+extension PrimaryAssociatedTypeClauseSyntax {
+  /// Creates a `PrimaryAssociatedTypeClauseSyntax` using the provided build function.
+  /// - Parameter:
+  ///   - build: A closure that will be invoked in order to initialize
+  ///            the fields of the syntax node.
+  ///            This closure is passed a `PrimaryAssociatedTypeClauseSyntaxBuilder` which you can use to
+  ///            incrementally build the structure of the node.
+  /// - Returns: A `PrimaryAssociatedTypeClauseSyntax` with all the fields populated in the builder
+  ///            closure.
+  public init(_ build: (inout PrimaryAssociatedTypeClauseSyntaxBuilder) -> Void) {
+    var builder = PrimaryAssociatedTypeClauseSyntaxBuilder()
+    build(&builder)
+    let data = builder.buildData()
+    self.init(data)
+  }
+}
+
 public struct SimpleTypeIdentifierSyntaxBuilder {
   private var layout =
     Array<RawSyntax?>(repeating: nil, count: 2)

Sources/SwiftSyntax/gyb_generated/SyntaxEnum.swift

@@ -227,6 +227,7 @@ public enum SyntaxEnum {
   case primaryAssociatedType(PrimaryAssociatedTypeSyntax)
   case genericParameterClause(GenericParameterClauseSyntax)
   case conformanceRequirement(ConformanceRequirementSyntax)
+  case primaryAssociatedTypeClause(PrimaryAssociatedTypeClauseSyntax)
   case simpleTypeIdentifier(SimpleTypeIdentifierSyntax)
   case memberTypeIdentifier(MemberTypeIdentifierSyntax)
   case classRestrictionType(ClassRestrictionTypeSyntax)
@@ -696,6 +697,8 @@ public extension Syntax {
       return .genericParameterClause(GenericParameterClauseSyntax(self)!)
     case .conformanceRequirement:
       return .conformanceRequirement(ConformanceRequirementSyntax(self)!)
+    case .primaryAssociatedTypeClause:
+      return .primaryAssociatedTypeClause(PrimaryAssociatedTypeClauseSyntax(self)!)
     case .simpleTypeIdentifier:
       return .simpleTypeIdentifier(SimpleTypeIdentifierSyntax(self)!)
     case .memberTypeIdentifier:

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -1937,12 +1937,13 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return StructDeclSyntax(data)
   }
-  public static func makeProtocolDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, protocolKeyword: TokenSyntax, identifier: TokenSyntax, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ProtocolDeclSyntax {
+  public static func makeProtocolDecl(attributes: AttributeListSyntax?, modifiers: ModifierListSyntax?, protocolKeyword: TokenSyntax, identifier: TokenSyntax, primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax?, inheritanceClause: TypeInheritanceClauseSyntax?, genericWhereClause: GenericWhereClauseSyntax?, members: MemberDeclBlockSyntax) -> ProtocolDeclSyntax {
     let layout: [RawSyntax?] = [
       attributes?.raw,
       modifiers?.raw,
       protocolKeyword.raw,
       identifier.raw,
+      primaryAssociatedTypeClause?.raw,
       inheritanceClause?.raw,
       genericWhereClause?.raw,
       members.raw,
@@ -1962,6 +1963,7 @@ public enum SyntaxFactory {
       RawSyntax.missingToken(TokenKind.identifier("")),
       nil,
       nil,
+      nil,
       RawSyntax.missing(SyntaxKind.memberDeclBlock),
     ], length: .zero, presence: .present))
     return ProtocolDeclSyntax(data)
@@ -4177,6 +4179,27 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return ConformanceRequirementSyntax(data)
   }
+  public static func makePrimaryAssociatedTypeClause(leftAngleBracket: TokenSyntax, primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax, rightAngleBracket: TokenSyntax) -> PrimaryAssociatedTypeClauseSyntax {
+    let layout: [RawSyntax?] = [
+      leftAngleBracket.raw,
+      primaryAssociatedTypeList.raw,
+      rightAngleBracket.raw,
+    ]
+    let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.primaryAssociatedTypeClause,
+      layout: layout, presence: SourcePresence.present)
+    let data = SyntaxData.forRoot(raw)
+    return PrimaryAssociatedTypeClauseSyntax(data)
+  }
+
+  public static func makeBlankPrimaryAssociatedTypeClause() -> PrimaryAssociatedTypeClauseSyntax {
+    let data = SyntaxData.forRoot(RawSyntax.create(kind: .primaryAssociatedTypeClause,
+      layout: [
+      RawSyntax.missingToken(TokenKind.leftAngle),
+      RawSyntax.missing(SyntaxKind.primaryAssociatedTypeList),
+      RawSyntax.missingToken(TokenKind.rightAngle),
+    ], length: .zero, presence: .present))
+    return PrimaryAssociatedTypeClauseSyntax(data)
+  }
   public static func makeSimpleTypeIdentifier(name: TokenSyntax, genericArgumentClause: GenericArgumentClauseSyntax?) -> SimpleTypeIdentifierSyntax {
     let layout: [RawSyntax?] = [
       name.raw,

Sources/SwiftSyntax/gyb_generated/SyntaxKind.swift

@@ -227,6 +227,7 @@ internal enum SyntaxKind: CSyntaxKind {
   case primaryAssociatedType = 255
   case genericParameterClause = 151
   case conformanceRequirement = 152
+  case primaryAssociatedTypeClause = 256
   case simpleTypeIdentifier = 212
   case memberTypeIdentifier = 213
   case classRestrictionType = 214

Sources/SwiftSyntax/gyb_generated/SyntaxRewriter.swift

@@ -1465,6 +1465,13 @@ open class SyntaxRewriter {
     return Syntax(visitChildren(node))
   }
 
+  /// Visit a `PrimaryAssociatedTypeClauseSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> Syntax {
+    return Syntax(visitChildren(node))
+  }
+
   /// Visit a `SimpleTypeIdentifierSyntax`.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -3875,6 +3882,16 @@ open class SyntaxRewriter {
       return visit(node)
   }
 
+  /// Implementation detail of visit(_:). Do not call directly.
+  private func visitImplPrimaryAssociatedTypeClauseSyntax(_ data: SyntaxData) -> Syntax {
+      let node = PrimaryAssociatedTypeClauseSyntax(data)
+      // Accessing _syntaxNode directly is faster than calling Syntax(node)
+      visitPre(node._syntaxNode)
+      defer { visitPost(node._syntaxNode) }
+      if let newNode = visitAny(node._syntaxNode) { return newNode }
+      return visit(node)
+  }
+
   /// Implementation detail of visit(_:). Do not call directly.
   private func visitImplSimpleTypeIdentifierSyntax(_ data: SyntaxData) -> Syntax {
       let node = SimpleTypeIdentifierSyntax(data)
@@ -4719,6 +4736,8 @@ open class SyntaxRewriter {
       return visitImplGenericParameterClauseSyntax
     case .conformanceRequirement:
       return visitImplConformanceRequirementSyntax
+    case .primaryAssociatedTypeClause:
+      return visitImplPrimaryAssociatedTypeClauseSyntax
     case .simpleTypeIdentifier:
       return visitImplSimpleTypeIdentifierSyntax
     case .memberTypeIdentifier:
@@ -5230,6 +5249,8 @@ open class SyntaxRewriter {
       return visitImplGenericParameterClauseSyntax(data)
     case .conformanceRequirement:
       return visitImplConformanceRequirementSyntax(data)
+    case .primaryAssociatedTypeClause:
+      return visitImplPrimaryAssociatedTypeClauseSyntax(data)
     case .simpleTypeIdentifier:
       return visitImplSimpleTypeIdentifierSyntax(data)
     case .memberTypeIdentifier:

Sources/SwiftSyntax/gyb_generated/SyntaxVisitor.swift

@@ -2092,6 +2092,16 @@ open class SyntaxVisitor {
   /// The function called after visiting `ConformanceRequirementSyntax` and its descendents.
   ///   - node: the node we just finished visiting.
   open func visitPost(_ node: ConformanceRequirementSyntax) {}
+  /// Visiting `PrimaryAssociatedTypeClauseSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: PrimaryAssociatedTypeClauseSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `PrimaryAssociatedTypeClauseSyntax` and its descendents.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: PrimaryAssociatedTypeClauseSyntax) {}
   /// Visiting `SimpleTypeIdentifierSyntax` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -4806,6 +4816,17 @@ open class SyntaxVisitor {
       visitPost(node)
   }
 
+  /// Implementation detail of doVisit(_:_:). Do not call directly.
+  private func visitImplPrimaryAssociatedTypeClauseSyntax(_ data: SyntaxData) {
+      let node = PrimaryAssociatedTypeClauseSyntax(data)
+      let needsChildren = (visit(node) == .visitChildren)
+      // Avoid calling into visitChildren if possible.
+      if needsChildren && node.raw.numberOfChildren > 0 {
+        visitChildren(node)
+      }
+      visitPost(node)
+  }
+
   /// Implementation detail of doVisit(_:_:). Do not call directly.
   private func visitImplSimpleTypeIdentifierSyntax(_ data: SyntaxData) {
       let node = SimpleTypeIdentifierSyntax(data)
@@ -5655,6 +5676,8 @@ open class SyntaxVisitor {
       visitImplGenericParameterClauseSyntax(data)
     case .conformanceRequirement:
       visitImplConformanceRequirementSyntax(data)
+    case .primaryAssociatedTypeClause:
+      visitImplPrimaryAssociatedTypeClauseSyntax(data)
     case .simpleTypeIdentifier:
       visitImplSimpleTypeIdentifierSyntax(data)
     case .memberTypeIdentifier: