Redo the Modeling of precedencegroup Data

Strike the "list" of designated types in favor of a single optional designated type node.

Author: CodaFi

Sources/SwiftParser/Declarations.swift

@@ -1882,10 +1882,28 @@ extension Parser {
     // checking.
     let precedenceAndTypes: RawOperatorPrecedenceAndTypesSyntax?
     if let colon = self.consume(if: .colon) {
-      let identifier = self.expectIdentifierWithoutRecovery()
+      let (unexpectedBeforeIdentifier, identifier) = self.expectIdentifier()
+      let unexpectedBeforeComma: RawUnexpectedNodesSyntax?
+      let comma: RawTokenSyntax?
+      let unexpectedBeforeDesignatedType: RawUnexpectedNodesSyntax?
+      let designatedType: RawTokenSyntax?
+      if self.at(.comma) {
+        (unexpectedBeforeComma, comma) = self.expect(.comma)
+        (unexpectedBeforeDesignatedType, designatedType) = self.expectIdentifier()
+      } else {
+        unexpectedBeforeComma = nil
+        comma = nil
+        unexpectedBeforeDesignatedType = nil
+        designatedType = nil
+      }
       precedenceAndTypes = RawOperatorPrecedenceAndTypesSyntax(
         colon: colon,
-        precedenceGroupAndDesignatedTypes: RawIdentifierListSyntax(elements: [ identifier ], arena: self.arena),
+        unexpectedBeforeIdentifier,
+        precedenceGroup: identifier,
+        unexpectedBeforeComma,
+        comma: comma,
+        unexpectedBeforeDesignatedType,
+        designatedType: designatedType,
         arena: self.arena)
     } else {
       precedenceAndTypes = nil

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -8637,17 +8637,25 @@ public struct RawOperatorPrecedenceAndTypesSyntax: RawSyntaxNodeProtocol {
   public init(
     _ unexpectedBeforeColon: RawUnexpectedNodesSyntax? = nil,
     colon: RawTokenSyntax,
-    _ unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes: RawUnexpectedNodesSyntax? = nil,
-    precedenceGroupAndDesignatedTypes: RawIdentifierListSyntax,
+    _ unexpectedBetweenColonAndPrecedenceGroup: RawUnexpectedNodesSyntax? = nil,
+    precedenceGroup: RawTokenSyntax,
+    _ unexpectedBetweenPrecedenceGroupAndComma: RawUnexpectedNodesSyntax? = nil,
+    comma: RawTokenSyntax?,
+    _ unexpectedBetweenCommaAndDesignatedType: RawUnexpectedNodesSyntax? = nil,
+    designatedType: RawTokenSyntax?,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .operatorPrecedenceAndTypes, uninitializedCount: 4, arena: arena) { layout in
+      kind: .operatorPrecedenceAndTypes, uninitializedCount: 8, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeColon?.raw
       layout[1] = colon.raw
-      layout[2] = unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes?.raw
-      layout[3] = precedenceGroupAndDesignatedTypes.raw
+      layout[2] = unexpectedBetweenColonAndPrecedenceGroup?.raw
+      layout[3] = precedenceGroup.raw
+      layout[4] = unexpectedBetweenPrecedenceGroupAndComma?.raw
+      layout[5] = comma?.raw
+      layout[6] = unexpectedBetweenCommaAndDesignatedType?.raw
+      layout[7] = designatedType?.raw
     }
     self.init(raw: raw)
   }
@@ -8658,11 +8666,23 @@ public struct RawOperatorPrecedenceAndTypesSyntax: RawSyntaxNodeProtocol {
   public var colon: RawTokenSyntax {
     layoutView.children[1].map(RawTokenSyntax.init(raw:))!
   }
-  public var unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes: RawUnexpectedNodesSyntax? {
+  public var unexpectedBetweenColonAndPrecedenceGroup: RawUnexpectedNodesSyntax? {
     layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
   }
-  public var precedenceGroupAndDesignatedTypes: RawIdentifierListSyntax {
-    layoutView.children[3].map(RawIdentifierListSyntax.init(raw:))!
+  public var precedenceGroup: RawTokenSyntax {
+    layoutView.children[3].map(RawTokenSyntax.init(raw:))!
+  }
+  public var unexpectedBetweenPrecedenceGroupAndComma: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var comma: RawTokenSyntax? {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))
+  }
+  public var unexpectedBetweenCommaAndDesignatedType: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+  public var designatedType: RawTokenSyntax? {
+    layoutView.children[7].map(RawTokenSyntax.init(raw:))
   }
 }
 

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -1236,11 +1236,15 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     }
     break
   case .operatorPrecedenceAndTypes:
-    assert(layout.count == 4)
+    assert(layout.count == 8)
     _verify(layout[0], as: RawUnexpectedNodesSyntax?.self)
     _verify(layout[1], as: RawTokenSyntax.self)
     _verify(layout[2], as: RawUnexpectedNodesSyntax?.self)
-    _verify(layout[3], as: RawIdentifierListSyntax.self)
+    _verify(layout[3], as: RawTokenSyntax.self)
+    _verify(layout[4], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[5], as: RawTokenSyntax?.self)
+    _verify(layout[6], as: RawUnexpectedNodesSyntax?.self)
+    _verify(layout[7], as: RawTokenSyntax?.self)
     break
   case .precedenceGroupDecl:
     assert(layout.count == 14)

Sources/SwiftSyntax/gyb_generated/SyntaxFactory.swift

@@ -3840,12 +3840,16 @@ public enum SyntaxFactory {
     return IdentifierListSyntax(data)
   }
   @available(*, deprecated, message: "Use initializer on OperatorPrecedenceAndTypesSyntax")
-  public static func makeOperatorPrecedenceAndTypes(_ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil, precedenceGroupAndDesignatedTypes: IdentifierListSyntax) -> OperatorPrecedenceAndTypesSyntax {
+  public static func makeOperatorPrecedenceAndTypes(_ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil, colon: TokenSyntax, _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil, precedenceGroup: TokenSyntax, _ unexpectedBetweenPrecedenceGroupAndComma: UnexpectedNodesSyntax? = nil, comma: TokenSyntax?, _ unexpectedBetweenCommaAndDesignatedType: UnexpectedNodesSyntax? = nil, designatedType: TokenSyntax?) -> OperatorPrecedenceAndTypesSyntax {
     let layout: [RawSyntax?] = [
       unexpectedBeforeColon?.raw,
       colon.raw,
-      unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes?.raw,
-      precedenceGroupAndDesignatedTypes.raw,
+      unexpectedBetweenColonAndPrecedenceGroup?.raw,
+      precedenceGroup.raw,
+      unexpectedBetweenPrecedenceGroupAndComma?.raw,
+      comma?.raw,
+      unexpectedBetweenCommaAndDesignatedType?.raw,
+      designatedType?.raw,
     ]
     let raw = RawSyntax.makeLayout(kind: SyntaxKind.operatorPrecedenceAndTypes,
       from: layout, arena: .default)
@@ -3860,7 +3864,11 @@ public enum SyntaxFactory {
       nil,
       RawSyntax.makeMissingToken(kind: TokenKind.colon, arena: .default),
       nil,
-      RawSyntax.makeEmptyLayout(kind: SyntaxKind.identifierList, arena: .default),
+      RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: .default),
+      nil,
+      nil,
+      nil,
+      nil,
     ], arena: .default))
     return OperatorPrecedenceAndTypesSyntax(data)
   }

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -7234,14 +7234,22 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable {
   public init(
     _ unexpectedBeforeColon: UnexpectedNodesSyntax? = nil,
     colon: TokenSyntax,
-    _ unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? = nil,
-    precedenceGroupAndDesignatedTypes: IdentifierListSyntax
+    _ unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? = nil,
+    precedenceGroup: TokenSyntax,
+    _ unexpectedBetweenPrecedenceGroupAndComma: UnexpectedNodesSyntax? = nil,
+    comma: TokenSyntax?,
+    _ unexpectedBetweenCommaAndDesignatedType: UnexpectedNodesSyntax? = nil,
+    designatedType: TokenSyntax?
   ) {
     let layout: [RawSyntax?] = [
       unexpectedBeforeColon?.raw,
       colon.raw,
-      unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes?.raw,
-      precedenceGroupAndDesignatedTypes.raw,
+      unexpectedBetweenColonAndPrecedenceGroup?.raw,
+      precedenceGroup.raw,
+      unexpectedBetweenPrecedenceGroupAndComma?.raw,
+      comma?.raw,
+      unexpectedBetweenCommaAndDesignatedType?.raw,
+      designatedType?.raw,
     ]
     let raw = RawSyntax.makeLayout(kind: SyntaxKind.operatorPrecedenceAndTypes,
       from: layout, arena: .default)
@@ -7290,65 +7298,134 @@ public struct OperatorPrecedenceAndTypesSyntax: SyntaxProtocol, SyntaxHashable {
     return OperatorPrecedenceAndTypesSyntax(newData)
   }
 
-  public var unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes: UnexpectedNodesSyntax? {
+  public var unexpectedBetweenColonAndPrecedenceGroup: UnexpectedNodesSyntax? {
     get {
       let childData = data.child(at: 2, parent: Syntax(self))
       if childData == nil { return nil }
       return UnexpectedNodesSyntax(childData!)
     }
     set(value) {
-      self = withUnexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes(value)
+      self = withUnexpectedBetweenColonAndPrecedenceGroup(value)
     }
   }
 
-  /// Returns a copy of the receiver with its `unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes` replaced.
-  /// - param newChild: The new `unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes` to replace the node's
-  ///                   current `unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes`, if present.
-  public func withUnexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes(
+  /// Returns a copy of the receiver with its `unexpectedBetweenColonAndPrecedenceGroup` replaced.
+  /// - param newChild: The new `unexpectedBetweenColonAndPrecedenceGroup` to replace the node's
+  ///                   current `unexpectedBetweenColonAndPrecedenceGroup`, if present.
+  public func withUnexpectedBetweenColonAndPrecedenceGroup(
     _ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax {
     let raw = newChild?.raw
     let newData = data.replacingChild(raw, at: 2)
     return OperatorPrecedenceAndTypesSyntax(newData)
   }
 
   /// 
-  /// The precedence group and designated types for this operator
+  /// The precedence group for this operator
   /// 
-  public var precedenceGroupAndDesignatedTypes: IdentifierListSyntax {
+  public var precedenceGroup: TokenSyntax {
     get {
       let childData = data.child(at: 3, parent: Syntax(self))
-      return IdentifierListSyntax(childData!)
+      return TokenSyntax(childData!)
     }
     set(value) {
-      self = withPrecedenceGroupAndDesignatedTypes(value)
+      self = withPrecedenceGroup(value)
     }
   }
 
-  /// Adds the provided `PrecedenceGroupAndDesignatedType` to the node's `precedenceGroupAndDesignatedTypes`
-  /// collection.
-  /// - param element: The new `PrecedenceGroupAndDesignatedType` to add to the node's
-  ///                  `precedenceGroupAndDesignatedTypes` collection.
-  /// - returns: A copy of the receiver with the provided `PrecedenceGroupAndDesignatedType`
-  ///            appended to its `precedenceGroupAndDesignatedTypes` collection.
-  public func addPrecedenceGroupAndDesignatedType(_ element: TokenSyntax) -> OperatorPrecedenceAndTypesSyntax {
-    var collection: RawSyntax
-    if let col = raw.layoutView!.children[3] {
-      collection = col.layoutView!.appending(element.raw, arena: .default)
-    } else {
-      collection = RawSyntax.makeLayout(kind: SyntaxKind.identifierList,
-        from: [element.raw], arena: .default)
+  /// Returns a copy of the receiver with its `precedenceGroup` replaced.
+  /// - param newChild: The new `precedenceGroup` to replace the node's
+  ///                   current `precedenceGroup`, if present.
+  public func withPrecedenceGroup(
+    _ newChild: TokenSyntax?) -> OperatorPrecedenceAndTypesSyntax {
+    let raw = newChild?.raw ?? RawSyntax.makeMissingToken(kind: TokenKind.identifier(""), arena: .default)
+    let newData = data.replacingChild(raw, at: 3)
+    return OperatorPrecedenceAndTypesSyntax(newData)
+  }
+
+  public var unexpectedBetweenPrecedenceGroupAndComma: UnexpectedNodesSyntax? {
+    get {
+      let childData = data.child(at: 4, parent: Syntax(self))
+      if childData == nil { return nil }
+      return UnexpectedNodesSyntax(childData!)
     }
-    let newData = data.replacingChild(collection, at: 3)
+    set(value) {
+      self = withUnexpectedBetweenPrecedenceGroupAndComma(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `unexpectedBetweenPrecedenceGroupAndComma` replaced.
+  /// - param newChild: The new `unexpectedBetweenPrecedenceGroupAndComma` to replace the node's
+  ///                   current `unexpectedBetweenPrecedenceGroupAndComma`, if present.
+  public func withUnexpectedBetweenPrecedenceGroupAndComma(
+    _ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: 4)
     return OperatorPrecedenceAndTypesSyntax(newData)
   }
 
-  /// Returns a copy of the receiver with its `precedenceGroupAndDesignatedTypes` replaced.
-  /// - param newChild: The new `precedenceGroupAndDesignatedTypes` to replace the node's
-  ///                   current `precedenceGroupAndDesignatedTypes`, if present.
-  public func withPrecedenceGroupAndDesignatedTypes(
-    _ newChild: IdentifierListSyntax?) -> OperatorPrecedenceAndTypesSyntax {
-    let raw = newChild?.raw ?? RawSyntax.makeEmptyLayout(kind: SyntaxKind.identifierList, arena: .default)
-    let newData = data.replacingChild(raw, at: 3)
+  public var comma: TokenSyntax? {
+    get {
+      let childData = data.child(at: 5, parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withComma(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `comma` replaced.
+  /// - param newChild: The new `comma` to replace the node's
+  ///                   current `comma`, if present.
+  public func withComma(
+    _ newChild: TokenSyntax?) -> OperatorPrecedenceAndTypesSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: 5)
+    return OperatorPrecedenceAndTypesSyntax(newData)
+  }
+
+  public var unexpectedBetweenCommaAndDesignatedType: UnexpectedNodesSyntax? {
+    get {
+      let childData = data.child(at: 6, parent: Syntax(self))
+      if childData == nil { return nil }
+      return UnexpectedNodesSyntax(childData!)
+    }
+    set(value) {
+      self = withUnexpectedBetweenCommaAndDesignatedType(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `unexpectedBetweenCommaAndDesignatedType` replaced.
+  /// - param newChild: The new `unexpectedBetweenCommaAndDesignatedType` to replace the node's
+  ///                   current `unexpectedBetweenCommaAndDesignatedType`, if present.
+  public func withUnexpectedBetweenCommaAndDesignatedType(
+    _ newChild: UnexpectedNodesSyntax?) -> OperatorPrecedenceAndTypesSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: 6)
+    return OperatorPrecedenceAndTypesSyntax(newData)
+  }
+
+  /// 
+  /// The designated types for this operator
+  /// 
+  public var designatedType: TokenSyntax? {
+    get {
+      let childData = data.child(at: 7, parent: Syntax(self))
+      if childData == nil { return nil }
+      return TokenSyntax(childData!)
+    }
+    set(value) {
+      self = withDesignatedType(value)
+    }
+  }
+
+  /// Returns a copy of the receiver with its `designatedType` replaced.
+  /// - param newChild: The new `designatedType` to replace the node's
+  ///                   current `designatedType`, if present.
+  public func withDesignatedType(
+    _ newChild: TokenSyntax?) -> OperatorPrecedenceAndTypesSyntax {
+    let raw = newChild?.raw
+    let newData = data.replacingChild(raw, at: 7)
     return OperatorPrecedenceAndTypesSyntax(newData)
   }
 }
@@ -7358,8 +7435,12 @@ extension OperatorPrecedenceAndTypesSyntax: CustomReflectable {
     return Mirror(self, children: [
       "unexpectedBeforeColon": unexpectedBeforeColon.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
       "colon": Syntax(colon).asProtocol(SyntaxProtocol.self),
-      "unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes": unexpectedBetweenColonAndPrecedenceGroupAndDesignatedTypes.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
-      "precedenceGroupAndDesignatedTypes": Syntax(precedenceGroupAndDesignatedTypes).asProtocol(SyntaxProtocol.self),
+      "unexpectedBetweenColonAndPrecedenceGroup": unexpectedBetweenColonAndPrecedenceGroup.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "precedenceGroup": Syntax(precedenceGroup).asProtocol(SyntaxProtocol.self),
+      "unexpectedBetweenPrecedenceGroupAndComma": unexpectedBetweenPrecedenceGroupAndComma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "comma": comma.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "unexpectedBetweenCommaAndDesignatedType": unexpectedBetweenCommaAndDesignatedType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
+      "designatedType": designatedType.map(Syntax.init)?.asProtocol(SyntaxProtocol.self) as Any,
     ])
   }
 }