[NFC-ish] Factor out InitSignature

Introduce and factor out a type that represents a list of children for which an initializer ought to exist.

This changes some `@available(renamed:)` values, but nothing that should change diagnostics or behavior.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/CompatibilityLayers.swift

@@ -16,7 +16,7 @@ public struct CompatibilityLayers /*: Sendable*/ {
   public var deprecatedVarsByNode: [SyntaxNodeKind: [Child]] = [:]
 
   /// Initializer signatures that are needed in the compatibility layer, in the order they ought to appear in the generated file.
-  public var deprecatedInitArgListsByNode: [SyntaxNodeKind: [[Child]]] = [:]
+  public var deprecatedInitSignaturesByNode: [SyntaxNodeKind: [InitSignature]] = [:]
 
   internal init(nodes: [Node]) {
     for node in nodes {
@@ -51,13 +51,13 @@ 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 && deprecatedInitArgListsByNode[node.syntaxNodeKind] == nil, let layoutNode = node.layoutNode else {
+    guard deprecatedVarsByNode[node.syntaxNodeKind] == nil && deprecatedInitSignaturesByNode[node.syntaxNodeKind] == nil, let layoutNode = node.layoutNode else {
       return
     }
 
     // The results that will ultimately be saved into the *ByNode dictionaries.
     var vars: [Child] = []
-    var initArgLists: [[Child]] = []
+    var initSignatures: [InitSignature] = []
 
     // Temporary working state for the loop.
     var children = layoutNode.children
@@ -108,11 +108,11 @@ 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 }
 
-      initArgLists.append(children)
+      initSignatures.append(InitSignature(children: children))
     }
 
     deprecatedVarsByNode[node.syntaxNodeKind] = vars
-    deprecatedInitArgListsByNode[node.syntaxNodeKind] = initArgLists
+    deprecatedInitSignaturesByNode[node.syntaxNodeKind] = initSignatures
   }
 }
 

CodeGeneration/Sources/SyntaxSupport/InitSignature.swift

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+public struct InitSignature: Hashable {
+  public var children: [Child]
+
+  public init(children: [Child]) {
+    self.children = children
+  }
+
+  public init(_ layoutNode: LayoutNode) {
+    self.init(children: layoutNode.children)
+  }
+
+  public init(_ trait: Trait) {
+    self.init(children: trait.children)
+  }
+}
+

CodeGeneration/Sources/generate-swift-syntax/LayoutNode+Extensions.swift renamed to CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift

@@ -15,11 +15,24 @@ import SwiftSyntaxBuilder
 import SyntaxSupport
 import Utils
 
-extension LayoutNode {
-  func generateInitializerDeclHeader(alternateChildren: [Child]? = nil) -> SyntaxNodeString {
-    let children = alternateChildren ?? self.children
+extension InitSignature {
+  var compoundName: String {
+    let renamedArguments = children.map { child in
+        if child.isUnexpectedNodes {
+          return "_:"
+        } else {
+          return "\(child.labelDeclName):"
+        }
+      }.joined(separator: "")
+
+    return "init(leadingTrivia:\(renamedArguments)trailingTrivia:)"
+  }
+
+  func generateInitializerDeclHeader(isRequirement: Bool = false) -> SyntaxNodeString {
+    let stub = isRequirement ? "init?" : "public init"
+
     if children.isEmpty {
-      return "public init()"
+      return "\(raw: stub)()"
     }
 
     func createFunctionParameterSyntax(for child: Child) -> FunctionParameterSyntax {
@@ -52,19 +65,23 @@ extension LayoutNode {
       )
     }
 
+    func transformParam(_ param: FunctionParameterSyntax) -> FunctionParameterSyntax {
+      isRequirement ? param.with(\.defaultValue, nil) : param
+    }
+
     let params = FunctionParameterListSyntax {
-      FunctionParameterSyntax("leadingTrivia: Trivia? = nil")
+      transformParam(FunctionParameterSyntax("leadingTrivia: Trivia? = nil"))
 
       for child in children {
-        createFunctionParameterSyntax(for: child)
+        transformParam(createFunctionParameterSyntax(for: child))
       }
 
-      FunctionParameterSyntax("trailingTrivia: Trivia? = nil")
-        .with(\.leadingTrivia, .newline)
+      transformParam(FunctionParameterSyntax("trailingTrivia: Trivia? = nil")
+                       .with(\.leadingTrivia, .newline))
     }
 
     return """
-      public init(
+      \(raw: stub)(
       \(params)
       )
       """
@@ -91,7 +108,7 @@ extension LayoutNode {
   }
 
   /// Create a builder-based convenience initializer, if needed.
-  func createConvenienceBuilderInitializer(alternateChildren: [Child]? = nil) throws -> InitializerDeclSyntax? {
+  func createConvenienceBuilderInitializer() throws -> InitializerDeclSyntax? {
     // Only create the convenience initializer if at least one parameter
     // is different than in the default initializer generated above.
     var shouldCreateInitializer = false
@@ -103,8 +120,6 @@ extension LayoutNode {
     var builderParameters: [FunctionParameterSyntax] = []
     var delegatedInitArgs: [LabeledExprSyntax] = []
 
-    let children = alternateChildren ?? self.children
-
     for child in children {
       /// The expression that is used to call the default initializer defined above.
       let produceExpr: ExprSyntax
@@ -192,3 +207,164 @@ fileprivate func convertFromSyntaxProtocolToSyntaxType(
   }
   return ExprSyntax("\(childName.declNameOrVarCallName)")
 }
+
+extension InitSignature {
+  /// Generates arguments to pass this initializer's parameters through to the
+  /// non-deprecated initializer. This will generate nested initializer calls for
+  /// any children with a compound `newerChildPath`.
+  func makeArgumentsToInitializeNewestChildren() -> [LabeledExprSyntax] {
+    var root: [InitParameterMapping] = []
+
+    for child in children {
+      InitParameterMapping.addChild(child, to: &root)
+    }
+
+    return root.map { $0.makeArgumentExpr() }
+  }
+}
+
+/// Represents the means by which a newest child, possibly at a nested position, is created from
+/// one or more historical children.
+///
+/// For example, consider a couple of nodes with some child history:
+/// ```
+/// Node(
+///   kind: .nestedNodeExtractedLater,
+///   children: [
+///     Child(name: "x", ...),
+///     Child(name: "y", ...),
+///   ]
+/// ),
+/// Node(
+///   kind: .longstandingNode,
+///   children: [
+///     Child(name: "a", ...),
+///     Child(name: "nested", kind: .node(.nestedNodeExtractedLater), ...),
+///   ],
+///   childHistory: [
+///     [
+///       "a": .renamed(from: "b"),
+///       "nested": .extracted
+///     ]
+///   ]
+/// )
+/// ```
+///
+/// These will end up being represented by `InitParameterMapping`s that look something like
+/// this (with string literals standing in for the object references):
+///
+/// ```swift
+/// [
+///   InitParameterMapping(
+///     newerChild: "child for current LongstandingNode.a",
+///     argument: .decl("child for historical LongstandingNode.b")
+///   ),
+///   InitParameterMapping(
+///     newerChild: "child for current LongstandingNode.nested",
+///     argument: .nestedInit(
+///       [
+///         InitParameterMapping(
+///           newerChild: "child for current NestedNodeExtractedLater.x",
+///           argument: .decl("child for historical LongstandingNode.x")
+///         ),
+///         InitParameterMapping(
+///           newerChild: "child for current NestedNodeExtractedLater.y",
+///           argument: .decl("child for historical LongstandingNode.y")
+///         )
+///       ]
+///     )
+///   )
+/// ]
+/// ```
+///
+/// Which matches the structure of the `self.init` arguments we must generate to call from the
+/// compatibility `LongstandingNodeSyntax.init(b:x:y:)` to the current
+/// `LongstandingNodeSyntax.init(a:nested:)`:
+///
+/// ```swift
+/// self.init(
+///   a: b,
+///   nested: NestedNodeExtractedLaterSyntax(
+///     x: x,
+///     y: y
+///   )
+/// )
+/// ```
+private struct InitParameterMapping {
+  var newerChild: Child
+  var argument: Argument
+
+  enum Argument {
+    case decl(olderChild: Child)
+    case nestedInit([InitParameterMapping])
+  }
+
+  static func addChild(_ olderChild: Child, to mappings: inout [InitParameterMapping]) {
+    guard !olderChild.newerChildPath.isEmpty else {
+      // This child is not historical, so we can just pass it right through.
+      mappings.append(
+        InitParameterMapping(
+          newerChild: olderChild,
+          argument: .decl(olderChild: olderChild)
+        )
+      )
+      return
+    }
+
+    let newerChildPath = olderChild.makeNewestChildPath()
+    addChild(olderChild, to: &mappings, at: newerChildPath[...])
+  }
+
+  private static func addChild(_ olderChild: Child, to mappings: inout [InitParameterMapping], at newerChildPath: ArraySlice<Child>) {
+    let targetNewerChild = newerChildPath.first!
+
+    if newerChildPath.count == 1 {
+      // We've found the argument list this ought to be added to.
+      let newMapping = InitParameterMapping(newerChild: targetNewerChild, argument: .decl(olderChild: olderChild))
+      mappings.append(newMapping)
+      return
+    }
+
+    // We've found a parent of the argument list this ought to be added to.
+    var (i, nestedArgMappings) = findOrCreateNestedInit(for: targetNewerChild, in: &mappings)
+    addChild(olderChild, to: &nestedArgMappings, at: newerChildPath.dropFirst())
+    mappings[i].argument = .nestedInit(nestedArgMappings)
+  }
+
+  private static func findOrCreateNestedInit(for newerChild: Child, in mappings: inout [InitParameterMapping]) -> (index: Int, nestedArgMapping: [InitParameterMapping]) {
+    // If there isn't an existing mapping, we'll append a new one.
+    guard let i = mappings.firstIndex(where: { $0.newerChild == newerChild }) else {
+      mappings.append(InitParameterMapping(newerChild: newerChild, argument: .nestedInit([])))
+      return (mappings.endIndex - 1, [])
+    }
+
+    // We found an existing mapping for this child and its nested children.
+    guard case .nestedInit(let nestedArgs) = mappings[i].argument else {
+      fatalError("Can't nest parameter inside parameter!")
+    }
+    return (i, nestedArgs)
+  }
+}
+
+extension InitParameterMapping {
+  func makeArgumentExpr() -> LabeledExprSyntax {
+    let argValue = switch argument {
+    case .decl(olderChild: let olderChild):
+      ExprSyntax(DeclReferenceExprSyntax(baseName: olderChild.baseCallName))
+
+    case .nestedInit(let initArgs):
+      ExprSyntax(
+        FunctionCallExprSyntax(callee: TypeExprSyntax(type: newerChild.syntaxNodeKind.syntaxType)) {
+          for initArg in initArgs {
+            initArg.makeArgumentExpr()
+          }
+        }
+      )
+    }
+
+    return LabeledExprSyntax(
+      label: newerChild.isUnexpectedNodes ? nil : newerChild.name,
+      expression: argValue
+    )
+  }
+}