Remove Modeling for Fully-Generic Primary Associated Type Syntax

Sources/SwiftSyntax/TokenKind.swift.gyb

@@ -47,7 +47,8 @@ public enum TokenKind {
   }
 
   /// The textual representation of this token kind.
-  var text: String {
+  @_spi(Testing)
+  public var text: String {
     switch self {
     case .eof: return ""
 % for token in SYNTAX_TOKENS:

Sources/SwiftSyntax/gyb_generated/SyntaxBuilders.swift

@@ -9176,49 +9176,23 @@ extension GenericParameterSyntax {
 
 public struct PrimaryAssociatedTypeSyntaxBuilder {
   private var layout =
-    Array<RawSyntax?>(repeating: nil, count: 6)
+    Array<RawSyntax?>(repeating: nil, count: 2)
 
   internal init() {}
 
-  public mutating func addAttribute(_ elt: Syntax) {
-    let idx = PrimaryAssociatedTypeSyntax.Cursor.attributes.rawValue
-    if let list = layout[idx] {
-      layout[idx] = list.appending(elt.raw)
-    } else {
-      layout[idx] = RawSyntax.create(kind: SyntaxKind.attributeList,
-        layout: [elt.raw], length: elt.raw.totalLength,
-        presence: SourcePresence.present)
-    }
-  }
-
   public mutating func useName(_ node: TokenSyntax) {
     let idx = PrimaryAssociatedTypeSyntax.Cursor.name.rawValue
     layout[idx] = node.raw
   }
 
-  public mutating func useColon(_ node: TokenSyntax) {
-    let idx = PrimaryAssociatedTypeSyntax.Cursor.colon.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useInheritedType(_ node: TypeSyntax) {
-    let idx = PrimaryAssociatedTypeSyntax.Cursor.inheritedType.rawValue
-    layout[idx] = node.raw
-  }
-
-  public mutating func useInitializer(_ node: TypeInitializerClauseSyntax) {
-    let idx = PrimaryAssociatedTypeSyntax.Cursor.initializer.rawValue
-    layout[idx] = node.raw
-  }
-
   public mutating func useTrailingComma(_ node: TokenSyntax) {
     let idx = PrimaryAssociatedTypeSyntax.Cursor.trailingComma.rawValue
     layout[idx] = node.raw
   }
 
   internal mutating func buildData() -> SyntaxData {
-    if (layout[1] == nil) {
-      layout[1] = RawSyntax.missingToken(TokenKind.identifier(""))
+    if (layout[0] == nil) {
+      layout[0] = RawSyntax.missingToken(TokenKind.identifier(""))
     }
 
     return .forRoot(RawSyntax.createAndCalcLength(kind: .primaryAssociatedType,

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -4164,13 +4164,9 @@ public enum SyntaxFactory {
     ], length: .zero, presence: .present))
     return PrimaryAssociatedTypeListSyntax(data)
   }
-  public static func makePrimaryAssociatedType(attributes: AttributeListSyntax?, name: TokenSyntax, colon: TokenSyntax?, inheritedType: TypeSyntax?, initializer: TypeInitializerClauseSyntax?, trailingComma: TokenSyntax?) -> PrimaryAssociatedTypeSyntax {
+  public static func makePrimaryAssociatedType(name: TokenSyntax, trailingComma: TokenSyntax?) -> PrimaryAssociatedTypeSyntax {
     let layout: [RawSyntax?] = [
-      attributes?.raw,
       name.raw,
-      colon?.raw,
-      inheritedType?.raw,
-      initializer?.raw,
       trailingComma?.raw,
     ]
     let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.primaryAssociatedType,
@@ -4182,12 +4178,8 @@ public enum SyntaxFactory {
   public static func makeBlankPrimaryAssociatedType() -> PrimaryAssociatedTypeSyntax {
     let data = SyntaxData.forRoot(RawSyntax.create(kind: .primaryAssociatedType,
       layout: [
-      nil,
       RawSyntax.missingToken(TokenKind.identifier("")),
       nil,
-      nil,
-      nil,
-      nil,
     ], length: .zero, presence: .present))
     return PrimaryAssociatedTypeSyntax(data)
   }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -11916,11 +11916,7 @@ extension GenericParameterSyntax: CustomReflectable {
 
 public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
   enum Cursor: Int {
-    case attributes
     case name
-    case colon
-    case inheritedType
-    case initializer
     case trailingComma
   }
 
@@ -11945,47 +11941,6 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     return Swift.type(of: self)
   }
 
-  public var attributes: AttributeListSyntax? {
-    get {
-      let childData = data.child(at: Cursor.attributes,
-                                 parent: Syntax(self))
-      if childData == nil { return nil }
-      return AttributeListSyntax(childData!)
-    }
-    set(value) {
-      self = withAttributes(value)
-    }
-  }
-
-  /// Adds the provided `Attribute` to the node's `attributes`
-  /// collection.
-  /// - param element: The new `Attribute` to add to the node's
-  ///                  `attributes` collection.
-  /// - returns: A copy of the receiver with the provided `Attribute`
-  ///            appended to its `attributes` collection.
-  public func addAttribute(_ element: Syntax) -> PrimaryAssociatedTypeSyntax {
-    var collection: RawSyntax
-    if let col = raw[Cursor.attributes] {
-      collection = col.appending(element.raw)
-    } else {
-      collection = RawSyntax.create(kind: SyntaxKind.attributeList,
-        layout: [element.raw], length: element.raw.totalLength, presence: .present)
-    }
-    let newData = data.replacingChild(collection,
-                                      at: Cursor.attributes)
-    return PrimaryAssociatedTypeSyntax(newData)
-  }
-
-  /// Returns a copy of the receiver with its `attributes` replaced.
-  /// - param newChild: The new `attributes` to replace the node's
-  ///                   current `attributes`, if present.
-  public func withAttributes(
-    _ newChild: AttributeListSyntax?) -> PrimaryAssociatedTypeSyntax {
-    let raw = newChild?.raw
-    let newData = data.replacingChild(raw, at: Cursor.attributes)
-    return PrimaryAssociatedTypeSyntax(newData)
-  }
-
   public var name: TokenSyntax {
     get {
       let childData = data.child(at: Cursor.name,
@@ -12007,72 +11962,6 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
     return PrimaryAssociatedTypeSyntax(newData)
   }
 
-  public var colon: TokenSyntax? {
-    get {
-      let childData = data.child(at: Cursor.colon,
-                                 parent: Syntax(self))
-      if childData == nil { return nil }
-      return TokenSyntax(childData!)
-    }
-    set(value) {
-      self = withColon(value)
-    }
-  }
-
-  /// Returns a copy of the receiver with its `colon` replaced.
-  /// - param newChild: The new `colon` to replace the node's
-  ///                   current `colon`, if present.
-  public func withColon(
-    _ newChild: TokenSyntax?) -> PrimaryAssociatedTypeSyntax {
-    let raw = newChild?.raw
-    let newData = data.replacingChild(raw, at: Cursor.colon)
-    return PrimaryAssociatedTypeSyntax(newData)
-  }
-
-  public var inheritedType: TypeSyntax? {
-    get {
-      let childData = data.child(at: Cursor.inheritedType,
-                                 parent: Syntax(self))
-      if childData == nil { return nil }
-      return TypeSyntax(childData!)
-    }
-    set(value) {
-      self = withInheritedType(value)
-    }
-  }
-
-  /// Returns a copy of the receiver with its `inheritedType` replaced.
-  /// - param newChild: The new `inheritedType` to replace the node's
-  ///                   current `inheritedType`, if present.
-  public func withInheritedType(
-    _ newChild: TypeSyntax?) -> PrimaryAssociatedTypeSyntax {
-    let raw = newChild?.raw
-    let newData = data.replacingChild(raw, at: Cursor.inheritedType)
-    return PrimaryAssociatedTypeSyntax(newData)
-  }
-
-  public var initializer: TypeInitializerClauseSyntax? {
-    get {
-      let childData = data.child(at: Cursor.initializer,
-                                 parent: Syntax(self))
-      if childData == nil { return nil }
-      return TypeInitializerClauseSyntax(childData!)
-    }
-    set(value) {
-      self = withInitializer(value)
-    }
-  }
-
-  /// Returns a copy of the receiver with its `initializer` replaced.
-  /// - param newChild: The new `initializer` to replace the node's
-  ///                   current `initializer`, if present.
-  public func withInitializer(
-    _ newChild: TypeInitializerClauseSyntax?) -> PrimaryAssociatedTypeSyntax {
-    let raw = newChild?.raw
-    let newData = data.replacingChild(raw, at: Cursor.initializer)
-    return PrimaryAssociatedTypeSyntax(newData)
-  }
-
   public var trailingComma: TokenSyntax? {
     get {
       let childData = data.child(at: Cursor.trailingComma,
@@ -12098,67 +11987,31 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable {
 
   public func _validateLayout() {
     let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
-    assert(rawChildren.count == 6)
-    // Check child #0 child is AttributeListSyntax or missing
+    assert(rawChildren.count == 2)
+    // Check child #0 child is TokenSyntax 
+    assert(rawChildren[0].raw != nil)
     if let raw = rawChildren[0].raw {
       let info = rawChildren[0].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(AttributeListSyntax.self))
+      assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #1 child is TokenSyntax 
-    assert(rawChildren[1].raw != nil)
+    // Check child #1 child is TokenSyntax or missing
     if let raw = rawChildren[1].raw {
       let info = rawChildren[1].syntaxInfo
       let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
       let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
       let syntaxChild = Syntax(syntaxData)
       assert(syntaxChild.is(TokenSyntax.self))
     }
-    // Check child #2 child is TokenSyntax or missing
-    if let raw = rawChildren[2].raw {
-      let info = rawChildren[2].syntaxInfo
-      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
-      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
-      let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(TokenSyntax.self))
-    }
-    // Check child #3 child is TypeSyntax or missing
-    if let raw = rawChildren[3].raw {
-      let info = rawChildren[3].syntaxInfo
-      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
-      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
-      let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(TypeSyntax.self))
-    }
-    // Check child #4 child is TypeInitializerClauseSyntax or missing
-    if let raw = rawChildren[4].raw {
-      let info = rawChildren[4].syntaxInfo
-      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
-      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
-      let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(TypeInitializerClauseSyntax.self))
-    }
-    // Check child #5 child is TokenSyntax or missing
-    if let raw = rawChildren[5].raw {
-      let info = rawChildren[5].syntaxInfo
-      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
-      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
-      let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(TokenSyntax.self))
-    }
   }
 }
 
 extension PrimaryAssociatedTypeSyntax: CustomReflectable {
   public var customMirror: Mirror {
     return Mirror(self, children: [
-      "attributes": attributes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "name": Syntax(name).asProtocol(SyntaxProtocol.self),
-      "colon": colon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
-      "inheritedType": inheritedType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
-      "initializer": initializer.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "trailingComma": trailingComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])
   }

Sources/SwiftSyntaxBuilder/gyb_generated/BuildableNodes.swift

@@ -12528,11 +12528,7 @@ public struct GenericParameter: SyntaxBuildable, ExpressibleAsGenericParameter,
 
 }
 public struct PrimaryAssociatedType: SyntaxBuildable, ExpressibleAsPrimaryAssociatedType, HasTrailingComma {
-  let attributes: AttributeList?
   let name: TokenSyntax
-  let colon: TokenSyntax?
-  let inheritedType: TypeBuildable?
-  let initializer: TypeInitializerClause?
   let trailingComma: TokenSyntax?
 
   /// The leading trivia attached to this syntax node once built.
@@ -12541,28 +12537,15 @@ public struct PrimaryAssociatedType: SyntaxBuildable, ExpressibleAsPrimaryAssoci
 
   /// Creates a `PrimaryAssociatedType` using the provided parameters.
   /// - Parameters:
-  ///   - attributes: 
   ///   - name: 
-  ///   - colon: 
-  ///   - inheritedType: 
-  ///   - initializer: 
   ///   - trailingComma: 
   public init(
     leadingTrivia: Trivia = [],
-    attributes: ExpressibleAsAttributeList? = nil,
     name: TokenSyntax,
-    colon: TokenSyntax? = nil,
-    inheritedType: ExpressibleAsTypeBuildable? = nil,
-    initializer: ExpressibleAsTypeInitializerClause? = nil,
     trailingComma: TokenSyntax? = nil
   ) {
     self.leadingTrivia = leadingTrivia
-    self.attributes = attributes?.createAttributeList()
     self.name = name
-    self.colon = colon
-    assert(colon == nil || colon!.text == ":")
-    self.inheritedType = inheritedType?.createTypeBuildable()
-    self.initializer = initializer?.createTypeInitializerClause()
     self.trailingComma = trailingComma
     assert(trailingComma == nil || trailingComma!.text == ",")
   }
@@ -12572,20 +12555,12 @@ public struct PrimaryAssociatedType: SyntaxBuildable, ExpressibleAsPrimaryAssoci
   ///  - Initializing tokens without default text using strings
   public init(
     leadingTrivia: Trivia = [],
-    attributes: ExpressibleAsAttributeList? = nil,
     name: String,
-    colon: TokenSyntax? = nil,
-    inheritedType: ExpressibleAsTypeBuildable? = nil,
-    initializer: ExpressibleAsTypeInitializerClause? = nil,
     trailingComma: TokenSyntax? = nil
   ) {
     self.init(
       leadingTrivia: leadingTrivia,
-      attributes: attributes,
       name: TokenSyntax.identifier(name),
-      colon: colon,
-      inheritedType: inheritedType,
-      initializer: initializer,
       trailingComma: trailingComma
     )
   }
@@ -12596,11 +12571,7 @@ public struct PrimaryAssociatedType: SyntaxBuildable, ExpressibleAsPrimaryAssoci
   /// - Returns: The built `PrimaryAssociatedTypeSyntax`.
   func buildPrimaryAssociatedType(format: Format, leadingTrivia additionalLeadingTrivia: Trivia? = nil) -> PrimaryAssociatedTypeSyntax {
     let result = SyntaxFactory.makePrimaryAssociatedType(
-      attributes: attributes?.buildAttributeList(format: format, leadingTrivia: nil),
       name: name,
-      colon: colon,
-      inheritedType: inheritedType?.buildType(format: format, leadingTrivia: nil),
-      initializer: initializer?.buildTypeInitializerClause(format: format, leadingTrivia: nil),
       trailingComma: trailingComma
     )
     let combinedLeadingTrivia = leadingTrivia + (additionalLeadingTrivia ?? []) + (result.leadingTrivia ?? [])
@@ -12621,11 +12592,7 @@ public struct PrimaryAssociatedType: SyntaxBuildable, ExpressibleAsPrimaryAssoci
   /// Conformance to `HasTrailingComma`.
   public func withTrailingComma(_ withComma: Bool) -> Self {
       return Self.init(
-        attributes: attributes,
         name: name,
-        colon: colon,
-        inheritedType: inheritedType,
-        initializer: initializer,
         trailingComma: withComma ? .comma : nil
       )
   }