Move layout validation to RawSyntax.

Validate the layout whenever the layout node is created.

Author: rintaro

Package.swift

@@ -56,6 +56,7 @@ let package = Package(
       exclude: [
         "Misc.swift.gyb",
         "RawSyntaxNodes.swift.gyb",
+        "RawSyntaxValidation.swift.gyb",
         "SyntaxAnyVisitor.swift.gyb",
         "SyntaxBaseNodes.swift.gyb",
         "SyntaxClassification.swift.gyb",

Sources/SwiftSyntax/RawSyntax.swift

@@ -735,6 +735,7 @@ extension RawSyntax {
     descendantCount: Int,
     arena: SyntaxArena
   ) -> RawSyntax {
+    validateLayout(layout: layout, as: kind)
     let payload = RawSyntaxData.Layout(
       kind: kind, layout: layout,
       byteLength: byteLength, descendantCount: descendantCount)
@@ -757,7 +758,6 @@ extension RawSyntax {
     // Allocate and initialize the list.
     let layoutBuffer = arena.allocateRawSyntaxBuffer(count: count)
     initializer(layoutBuffer)
-    // validateLayout(layout: RawSyntaxBuffer(layoutBuffer), as: kind)
 
     // Calculate the "byte width".
     var byteLength = 0

Sources/SwiftSyntax/RawSyntaxValidation.swift.gyb

@@ -0,0 +1,55 @@
+%{
+  from gyb_syntax_support import *
+  # -*- mode: Swift -*-
+  # Ignore the following admonition; it applies to the resulting .swift file only
+}%
+//// Automatically Generated From RawSyntaxValidation.swift.gyb.
+//// Do Not Edit Directly!
+//===----------- RawSyntaxValidation.swift - Layout validation ------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+
+
+/// Check that the `layout` is valid for the given 'SyntaxKind'.
+///
+/// Note that this only validates the immediate children.
+/// Results in an assertion failure if the layout is invalid.
+func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
+#if DEBUG
+  func _verify<Node: RawSyntaxNodeProtocol>(_ raw: RawSyntax?, as _: Node.Type, file: StaticString = #file, line: UInt = #line) {
+    assert(raw != nil, file: file, line: line)
+    assert(Node.isKindOf(raw!), file: file, line: line)
+  }
+  func _verify<Node: RawSyntaxNodeProtocol>(_ raw: RawSyntax?, as _: Node?.Type, file: StaticString = #file, line: UInt = #line) {
+    raw.map { assert(Node.isKindOf($0), file: file, line: line) }
+  }
+  switch kind {
+  case .unknown:
+    break
+  case .token:
+    assertionFailure("validateLayout for .token kind is not supported")
+% for node in NON_BASE_SYNTAX_NODES:
+  case .${node.swift_syntax_kind}:
+%   if node.is_buildable() or node.is_missing():
+    assert(layout.count == ${len(node.children)})
+%     for (idx, child) in enumerate(node.children):
+    _verify(layout[${idx}], as: Raw${child.type_name}${"?" if child.is_optional else ""}.self)
+%     end
+%   elif node.is_syntax_collection():
+    for element in layout {
+      _verify(element, as: Raw${node.collection_element_type}.self)
+    }
+%   end
+    break
+% end
+  }
+#endif
+}

Sources/SwiftSyntax/Syntax.swift

@@ -29,11 +29,6 @@ public struct Syntax: SyntaxProtocol, SyntaxHashable {
     self.init(.forRoot(raw))
   }
 
-  public func _validateLayout() {
-    // Check the layout of the concrete type
-    return self.asProtocol(SyntaxProtocol.self)._validateLayout()
-  }
-
   /// Create a `Syntax` node from a specialized syntax node.
   public init<S: SyntaxProtocol>(_ syntax: S) {
     self = syntax._syntaxNode
@@ -119,11 +114,6 @@ public protocol SyntaxProtocol: CustomStringConvertible,
   /// conversion is not possible.
   init?(_ syntaxNode: Syntax)
 
-  /// Check that the raw layout of this node is valid. Used to verify a node's
-  /// integrity after it has been rewritten by the syntax rewriter.
-  /// Results in an assertion failure if the layout is invalid.
-  func _validateLayout()
-
   /// Returns the underlying syntax node type.
   var syntaxNodeType: SyntaxProtocol.Type { get }
 }

Sources/SwiftSyntax/SyntaxBaseNodes.swift.gyb

@@ -103,11 +103,6 @@ public struct ${node.name}: ${node.name}Protocol, SyntaxHashable {
     return _syntaxNode.syntaxNodeType
   }
 
-  public func _validateLayout() {
-    // Check the layout of the concrete type
-    return Syntax(self)._validateLayout()
-  }
-
   public func `is`<S: ${node.name}Protocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -217,13 +217,6 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
       self = withTrailingTrivia(newValue ?? [])
     }
   }
-
-  public func _validateLayout() {
-    // Check that all children match the expected element type
-    assert(self.allSatisfy { node in
-      return Syntax(node).is(${node.collection_element_type}.self)
-    })
-  }
 }
 
 /// Conformance for `${node.name}` to the `BidirectionalCollection` protocol.

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -189,33 +189,6 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
     return ${node.name}(newData)
   }
 %     end
-
-%     # ===================
-%     # Validate layout
-%     # ===================
-
-  public func _validateLayout() {
-%     if node.is_unknown():
-    // We are verifying an unknown node. Since we don’t know anything about it
-    // we need to assume it’s valid.
-%     else:
-    let rawChildren = Array(RawSyntaxChildren(Syntax(self)))
-    assert(rawChildren.count == ${len(node.children)})
-%       for i, child in enumerate(node.children):
-    // Check child #${i} child is ${child.type_name} ${"or missing" if child.is_optional else ""}
-%         if not child.is_optional:
-    assert(rawChildren[${i}].raw != nil)
-%         end
-    if let raw = rawChildren[${i}].raw {
-      let info = rawChildren[${i}].syntaxInfo
-      let absoluteRaw = AbsoluteRawSyntax(raw: raw, info: info)
-      let syntaxData = SyntaxData(absoluteRaw, parent: Syntax(self))
-      let syntaxChild = Syntax(syntaxData)
-      assert(syntaxChild.is(${child.type_name}.self))
-    }
-%       end
-%     end
-  }
 }
 
 extension ${node.name}: CustomReflectable {

Sources/SwiftSyntax/SyntaxOtherNodes.swift

@@ -29,11 +29,6 @@ public struct UnknownSyntax: SyntaxProtocol, SyntaxHashable {
     return Swift.type(of: self)
   }
 
-  public func _validateLayout() {
-    // We are verifying an unknown node. Since we don’t know anything about it
-    // we need to assume it’s valid.
-  }
-
   /// Creates an `UnknownSyntax` node from the given `SyntaxData`. This assumes
   /// that the `SyntaxData` is of the correct kind. If it is not, the behaviour
   /// is undefined.
@@ -93,10 +88,6 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     return Swift.type(of: self)
   }
 
-  public func _validateLayout() {
-    /// A token is always valid as it has no children. Nothing to do here.
-  }
-
   public var presence: SourcePresence {
     return raw.presence
   }

Sources/SwiftSyntax/SyntaxRewriter.swift.gyb

@@ -255,11 +255,6 @@ open class SyntaxRewriter {
 
       let newRaw = node.raw.replacingLayout(Array(newLayout))
       let newNode = SyntaxType(Syntax(SyntaxData.forRoot(newRaw)))!
-      assert({
-        // In assertion builds inovoke the _validateLayout method
-        newNode._validateLayout()
-        return true
-      }())
       return newNode
     } else {
       // No child node was rewritten. So no need to change this node as well.