[NFC-ish] Support child history for traits

It’s always been possible to specify deprecated children, but nothing was actually done with the info until now.

Turns some manaully-generated decls into automatically-generated ones, but doesn’t change anything user-facing.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/CompatibilityLayers.swift

@@ -18,10 +18,19 @@ public struct CompatibilityLayers /*: Sendable*/ {
   /// Initializer signatures that are needed in the compatibility layer, in the order they ought to appear in the generated file.
   public var deprecatedInitSignaturesByNode: [SyntaxNodeKind: [InitSignature]] = [:]
 
-  internal init(nodes: [Node]) {
+  /// Properties that are needed in the compatibility layer, in the order they ought to appear in the generated file.
+  public var deprecatedVarsByTrait: [String: [Child]] = [:]
+
+  /// Initializer signatures that are needed in the compatibility layer, in the order they ought to appear in the generated file.
+  public var deprecatedInitSignaturesByTrait: [String: [InitSignature]] = [:]
+
+  internal init(nodes: [Node], traits: [Trait]) {
     for node in nodes {
       realizeLayers(for: node)
     }
+    for trait in traits {
+      realizeLayers(for: trait)
+    }
   }
 
   private func extractedChildren(in layoutNode: LayoutNode) -> ArraySlice<Child> {
@@ -70,26 +79,60 @@ public struct CompatibilityLayers /*: Sendable*/ {
 
   /// Compute and cache compatibility layer information for the given node, unless it is already present.
   private mutating func realizeLayers(for node: Node) {
-    guard deprecatedVarsByNode[node.syntaxNodeKind] == nil && deprecatedInitSignaturesByNode[node.syntaxNodeKind] == nil, let layoutNode = node.layoutNode else {
+    guard deprecatedVarsByNode[node.syntaxNodeKind] == nil, let layoutNode = node.layoutNode else {
+      return
+    }
+
+    let result = computeLayersFor(
+      typeName: layoutNode.kind.rawValue,
+      initialChildren: layoutNode.children,
+      history: layoutNode.childHistory,
+      areRequirements: false
+    )
+
+    deprecatedVarsByNode[node.syntaxNodeKind] = result.vars
+    deprecatedInitSignaturesByNode[node.syntaxNodeKind] = result.initSignatures
+  }
+
+  private mutating func realizeLayers(for trait: Trait) {
+    guard deprecatedVarsByTrait[trait.traitName] == nil else {
       return
     }
 
+    let result = computeLayersFor(
+      typeName: trait.traitName,
+      initialChildren: trait.children,
+      history: trait.childHistory,
+      areRequirements: true
+    )
+
+    deprecatedVarsByTrait[trait.traitName] = result.vars
+    deprecatedInitSignaturesByTrait[trait.traitName] = result.initSignatures
+  }
+
+  /// Compute and cache compatibility layer information for the given children.
+  private mutating func computeLayersFor(
+    typeName: String,
+    initialChildren: [Child],
+    history: Child.History,
+    areRequirements: Bool
+  ) -> (vars: [Child], initSignatures: [InitSignature]) {
     // The results that will ultimately be saved into the *ByNode dictionaries.
     var vars: [Child] = []
     var initSignatures: [InitSignature] = []
 
     // Temporary working state for the loop.
-    var children = layoutNode.children
+    var children = initialChildren
     var knownVars = Set(children)
 
     func firstIndexOfChild(named targetName: String) -> Int {
       guard let i = children.firstIndex(where: { $0.name == targetName }) else {
-        fatalError("couldn't find '\(targetName)' in current children of \(node.syntaxNodeKind.rawValue): \(String(reflecting: children.map(\.name)))")
+        fatalError("couldn't find '\(targetName)' in current children of \(typeName): \(String(reflecting: children.map(\.name)))")
       }
       return i
     }
 
-    for changeSet in layoutNode.childHistory {
+    for changeSet in history {
       var unexpectedChildrenWithNewNames: Set<Child> = []
 
       // First pass: Apply the changes explicitly specified in the change set.
@@ -99,12 +142,14 @@ public struct CompatibilityLayers /*: Sendable*/ {
         let replacementChildren = replacementChildren(for: children[i], by: refactoring)
         children.replaceSubrange(i...i, with: replacementChildren)
 
-        // Mark adjacent unexpected node children whose names have changed too.
-        if currentName != (replacementChildren.first?.name ?? "") {
-          unexpectedChildrenWithNewNames.insert(children[i - 1])
-        }
-        if currentName != (replacementChildren.last?.name ?? "") {
-          unexpectedChildrenWithNewNames.insert(children[i + replacementChildren.count])
+        if !areRequirements {
+          // Mark adjacent unexpected node children whose names have changed too.
+          if currentName != (replacementChildren.first?.name ?? "") {
+            unexpectedChildrenWithNewNames.insert(children[i - 1])
+          }
+          if currentName != (replacementChildren.last?.name ?? "") {
+            unexpectedChildrenWithNewNames.insert(children[i + replacementChildren.count])
+          }
         }
       }
 
@@ -127,11 +172,13 @@ public struct CompatibilityLayers /*: Sendable*/ {
       // Third pass: Append newly-created children to vars. We do this now so that changes from the first two passes are properly interleaved, preserving source order.
       vars += children.filter { knownVars.insert($0).inserted }
 
-      initSignatures.append(InitSignature(children: children))
+      // We don't create compatibility layers for protocol requirement inits.
+      if !areRequirements {
+        initSignatures.append(InitSignature(children: children))
+      }
     }
 
-    deprecatedVarsByNode[node.syntaxNodeKind] = vars
-    deprecatedInitSignaturesByNode[node.syntaxNodeKind] = initSignatures
+    return (vars, initSignatures)
   }
 }
 

CodeGeneration/Sources/SyntaxSupport/SyntaxNodes.swift

@@ -36,4 +36,4 @@ public let SYNTAX_NODE_MAP: [SyntaxNodeKind: Node] = Dictionary(
 
 public let NON_BASE_SYNTAX_NODES = SYNTAX_NODES.filter { !$0.kind.isBase }
 
-public let SYNTAX_COMPATIBILITY_LAYERS = CompatibilityLayers(nodes: SYNTAX_NODES)
+public let SYNTAX_COMPATIBILITY_LAYERS = CompatibilityLayers(nodes: SYNTAX_NODES, traits: TRAITS)

CodeGeneration/Sources/SyntaxSupport/Traits.swift

@@ -22,6 +22,7 @@ public class Trait {
   public let protocolName: TokenSyntax
   public let documentation: SwiftSyntax.Trivia
   public let children: [Child]
+  public let childHistory: Child.History
 
   init(traitName: String, baseKind: SyntaxNodeKind? = nil, documentation: String? = nil, children: [Child], childHistory: Child.History = []) {
     precondition(baseKind?.isBase != false, "`baseKind` must be a base syntax node kind")
@@ -30,7 +31,7 @@ public class Trait {
     self.protocolName = .identifier("\(traitName)Syntax")
     self.documentation = SwiftSyntax.Trivia.docCommentTrivia(from: documentation)
     self.children = children
-    // FIXME: We don't appear to have ever generated compatibility layers for children of traits!
+    self.childHistory = childHistory
   }
 }
 
@@ -98,6 +99,7 @@ public let TRAITS: [Trait] = [
         "pound": .renamed(from: "poundToken"),
         "macroName": .renamed(from: "macro"),
         "arguments": .renamed(from: "argumentList"),
+        "genericArgumentClause": .renamed(from: "genericArguments"),
       ]
     ]
   ),

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RenamedChildrenCompatibilityFile.swift

@@ -34,6 +34,22 @@ let renamedChildrenCompatibilityFile = try! SourceFileSyntax(leadingTrivia: copy
       }
     }
   }
+
+  for trait in TRAITS.filter({ !$0.childHistory.isEmpty }) {
+    var deprecatedVars = SYNTAX_COMPATIBILITY_LAYERS.deprecatedVarsByTrait[trait.traitName] ?? []
+    var deprecatedArgLists = SYNTAX_COMPATIBILITY_LAYERS.deprecatedInitSignaturesByTrait[trait.traitName] ?? []
+
+    try ExtensionDeclSyntax("extension \(trait.protocolName)") {
+      for child in deprecatedVars {
+        makeCompatibilityVar(for: child)
+        if let addMethod = makeCompatibilityAddMethod(for: child) {
+          addMethod
+        }
+      }
+
+      // Not currently generating compatibility inits for traits.
+    }
+  }
 }
 
 func makeCompatibilityVar(for child: Child) -> DeclSyntax {

Sources/SwiftSyntax/SwiftSyntaxCompatibility.swift

@@ -350,48 +350,6 @@ extension FunctionEffectSpecifiersSyntax {
   }
 }
 
-extension FreestandingMacroExpansionSyntax {
-  @available(*, deprecated, renamed: "pound")
-  public var poundToken: TokenSyntax {
-    get {
-      return pound
-    }
-    set {
-      pound = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "macroName")
-  public var macro: TokenSyntax {
-    get {
-      return macroName
-    }
-    set {
-      macroName = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "genericArgumentClause")
-  public var genericArguments: GenericArgumentClauseSyntax? {
-    get {
-      return genericArgumentClause
-    }
-    set {
-      genericArgumentClause = newValue
-    }
-  }
-
-  @available(*, deprecated, renamed: "arguments")
-  public var argumentList: LabeledExprListSyntax {
-    get {
-      return arguments
-    }
-    set {
-      arguments = newValue
-    }
-  }
-}
-
 extension GenericRequirementSyntax {
   @available(*, deprecated, renamed: "Requirement")
   public typealias Body = Requirement

Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift

@@ -8559,3 +8559,45 @@ extension YieldedExpressionsClauseSyntax {
     )
   }
 }
+
+extension FreestandingMacroExpansionSyntax {
+  @available(*, deprecated, renamed: "pound")
+  public var poundToken: TokenSyntax {
+    get {
+      return pound
+    }
+    set {
+      pound = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "macroName")
+  public var macro: TokenSyntax {
+    get {
+      return macroName
+    }
+    set {
+      macroName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "genericArgumentClause")
+  public var genericArguments: GenericArgumentClauseSyntax? {
+    get {
+      return genericArgumentClause
+    }
+    set {
+      genericArgumentClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "arguments")
+  public var argumentList: LabeledExprListSyntax {
+    get {
+      return arguments
+    }
+    set {
+      arguments = newValue
+    }
+  }
+}