[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/CompatibilityLayer.swift

@@ -15,6 +15,9 @@ public struct CompatibilityLayer {
   /// Deprecated members that the compatibility layer needs for each node.
   private var deprecatedMembersByNode: [SyntaxNodeKind: DeprecatedMemberInfo] = [:]
 
+  /// Deprecated members that the compatibility layer needs for each trait.
+  public var deprecatedMembersByTrait: [String: DeprecatedMemberInfo] = [:]
+
   /// Cache for `replacementChildren(for:by:)`. Ensures that we don't create two different replacement children even
   /// if we refactor the same child twice, so we can reliably equate and hash `Child` objects by object identity.
   private var cachedReplacementChildren: [Child: [Child]] = [:]
@@ -24,13 +27,21 @@ public struct CompatibilityLayer {
     return deprecatedMembersByNode[node.kind] ?? DeprecatedMemberInfo()
   }
 
-  internal init(nodes: [Node]) {
+  /// Returns the deprecated members that the compatibility layer needs for `trait`.
+  public func deprecatedMembers(for trait: Trait) -> DeprecatedMemberInfo {
+    return deprecatedMembersByTrait[trait.traitName] ?? DeprecatedMemberInfo()
+  }
+
+  internal init(nodes: [Node], traits: [Trait]) {
     // This instance will be stored in a global that's used from multiple threads simultaneously, so it won't be safe
     // to mutate once the initializer returns. We therefore do all the work to populate its tables up front, rather
     // than computing it lazily on demand.
     for node in nodes {
       computeMembers(for: node)
     }
+    for trait in traits {
+      computeMembers(for: trait)
+    }
   }
 
   /// Returns the child or children that would have existed in place of this
@@ -79,22 +90,54 @@ public struct CompatibilityLayer {
       return
     }
 
+    let result = computeMembersFor(
+      typeName: layoutNode.kind.rawValue,
+      initialChildren: layoutNode.children,
+      history: layoutNode.childHistory,
+      areRequirements: false
+    )
+
+    deprecatedMembersByNode[node.syntaxNodeKind] = result
+  }
+
+  private mutating func computeMembers(for trait: Trait) {
+    guard deprecatedMembersByTrait[trait.traitName] == nil else {
+      return
+    }
+
+    let result = computeMembersFor(
+      typeName: trait.traitName,
+      initialChildren: trait.children,
+      history: trait.childHistory,
+      areRequirements: true
+    )
+
+    deprecatedMembersByTrait[trait.traitName] = result
+  }
+
+  /// Compute and cache compatibility layer information for the given children.
+  private mutating func computeMembersFor(
+    typeName: String,
+    initialChildren: [Child],
+    history: Child.History,
+    areRequirements: Bool
+  ) -> DeprecatedMemberInfo {
     // The results that will ultimately be saved into the DeprecatedMemberInfo.
     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.
@@ -104,12 +147,14 @@ public struct CompatibilityLayer {
         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])
+          }
         }
       }
 
@@ -132,10 +177,13 @@ public struct CompatibilityLayer {
       // 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))
+      }
     }
 
-    deprecatedMembersByNode[node.syntaxNodeKind] = DeprecatedMemberInfo(vars: vars, inits: initSignatures)
+    return DeprecatedMemberInfo(vars: vars, inits: 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_LAYER = CompatibilityLayer(nodes: SYNTAX_NODES)
+public let SYNTAX_COMPATIBILITY_LAYER = CompatibilityLayer(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

@@ -33,6 +33,21 @@ let renamedChildrenCompatibilityFile = try! SourceFileSyntax(leadingTrivia: copy
       }
     }
   }
+
+  for trait in TRAITS.filter({ !$0.childHistory.isEmpty }) {
+    var deprecatedMembers = SYNTAX_COMPATIBILITY_LAYER.deprecatedMembers(for: trait)
+
+    try ExtensionDeclSyntax("extension \(trait.protocolName)") {
+      for child in deprecatedMembers.vars {
+        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
+    }
+  }
+}