[Experiment] Make Syntax nodes structs instead of classes

Author: harlanhaskins

test/SwiftSyntax/LazyCaching.swift

@@ -15,7 +15,8 @@ LazyCaching.test("Pathological") {
   let tuple = SyntaxFactory.makeVoidTupleType()
 
   DispatchQueue.concurrentPerform(iterations: 100) { _ in
-    expectEqual(tuple.leftParen, tuple.leftParen)
+    expectEqual(tuple.leftParen.uniqueIdentifier, 
+                tuple.leftParen.uniqueIdentifier)
   }
 }
 
@@ -41,9 +42,9 @@ LazyCaching.test("TwoAccesses") {
 
   expectNotNil(node1)
   expectNotNil(node2)
-  expectEqual(node1, node2)
-  expectEqual(node1, final)
-  expectEqual(node2, final)
+  expectEqual(node1?.uniqueIdentifier, node2?.uniqueIdentifier)
+  expectEqual(node1?.uniqueIdentifier, final.uniqueIdentifier)
+  expectEqual(node2?.uniqueIdentifier, final.uniqueIdentifier)
 }
 
 runAllTests()

test/SwiftSyntax/SyntaxFactory.swift

@@ -52,15 +52,18 @@ SyntaxFactoryAPI.test("Generated") {
               }
               """)
 
-  expectNotEqual(structDecl.members, renamed.members)
-  expectEqual(structDecl, structDecl.root)
+  expectNotEqual(structDecl.members.uniqueIdentifier, 
+                 renamed.members.uniqueIdentifier)
+  expectEqual(structDecl.uniqueIdentifier, structDecl.root.uniqueIdentifier)
   expectNil(structDecl.parent)
   expectNotNil(structDecl.members.parent)
-  expectEqual(structDecl.members.parent, structDecl)
+  expectEqual(structDecl.members.parent?.uniqueIdentifier, 
+              structDecl.uniqueIdentifier)
 
   // Ensure that accessing children via named identifiers is exactly the
   // same as accessing them as their underlying data.
-  expectEqual(structDecl.members, structDecl.child(at: 7))
+  expectEqual(structDecl.members.uniqueIdentifier, 
+              structDecl.child(at: 7)?.uniqueIdentifier)
 
   expectEqual("\(structDecl.members.rightBrace)",
               """

test/SwiftSyntax/VisitorTest.swift

@@ -31,10 +31,10 @@ VisitorTests.test("Basic") {
   expectDoesNotThrow({
     let parsed = try Syntax.parse(getInput("visitor.swift"))
     let counter = FuncCounter()
-    let hashBefore = parsed.hashValue
+    let idBefore = parsed.uniqueIdentifier
     counter.visit(parsed)
     expectEqual(counter.funcCount, 3)
-    expectEqual(hashBefore, parsed.hashValue)
+    expectEqual(idBefore, parsed.uniqueIdentifier)
   })
 }
 

tools/SwiftSyntax/SwiftSyntax.swift

@@ -44,7 +44,7 @@ extension Syntax {
     }
     let decoder = JSONDecoder()
     let raw = try decoder.decode(RawSyntax.self, from: result.stdoutData)
-    guard let file = Syntax.fromRaw(raw) as? SourceFileSyntax else {
+    guard let file = makeSyntax(raw) as? SourceFileSyntax else {
       throw ParserError.invalidFile
     }
     return file

tools/SwiftSyntax/Syntax.swift

@@ -15,41 +15,58 @@ import Foundation
 /// A Syntax node represents a tree of nodes with tokens at the leaves.
 /// Each node has accessors for its known children, and allows efficient
 /// iteration over the children through its `children` property.
-public class Syntax: CustomStringConvertible {
+public protocol Syntax: 
+  CustomStringConvertible, TextOutputStreamable {}
+
+internal protocol _SyntaxBase: Syntax {
   /// The type of sequence containing the indices of present children.
-  internal typealias PresentChildIndicesSequence =
+  typealias PresentChildIndicesSequence =
     LazyFilterSequence<CountableRange<Int>>
-
+    
   /// The root of the tree this node is currently in.
-  internal let _root: SyntaxData
+  var _root: SyntaxData { get } // Must be of type SyntaxData
 
   /// The data backing this node.
   /// - note: This is unowned, because the reference to the root data keeps it
   ///         alive. This means there is an implicit relationship -- the data
   ///         property must be a descendent of the root. This relationship must
   ///         be preserved in all circumstances where Syntax nodes are created.
-  internal unowned var data: SyntaxData
+  var _data: SyntaxData { get }
 
 #if DEBUG
-  func validate() {
-    // This is for subclasses to override to perform structural validation.
-  }
+  func validate()
 #endif
+}
+extension _SyntaxBase {
+  public func validate() {
+    // This is for implementers to override to perform structural validation.
+  }
+}
 
-  /// Creates a Syntax node from the provided root and data.
-  internal init(root: SyntaxData, data: SyntaxData) {
-    self._root = root
-    self.data = data
-#if DEBUG
-    validate()
-#endif
+extension Syntax {
+  var data: SyntaxData {
+    guard let base = self as? _SyntaxBase else {
+      fatalError("only first-class syntax nodes can conform to Syntax")
+    }
+    return base._data
+  }
+
+  var _root: SyntaxData {
+    guard let base = self as? _SyntaxBase else {
+      fatalError("only first-class syntax nodes can conform to Syntax")
+    }
+    return base._root
   }
 
   /// Access the raw syntax assuming the node is a Syntax.
   var raw: RawSyntax {
     return data.raw
   }
 
+  public var uniqueIdentifier: Int {
+    return ObjectIdentifier(data).hashValue
+  }
+
   /// An iterator over children of this node.
   public var children: SyntaxChildren {
     return SyntaxChildren(node: self)
@@ -93,7 +110,7 @@ public class Syntax: CustomStringConvertible {
   /// The parent of this syntax node, or `nil` if this node is the root.
   public var parent: Syntax? {
     guard let parentData = data.parent else { return nil }
-    return Syntax.make(root: _root, data: parentData)
+    return makeSyntax(root: _root, data: parentData)
   }
 
   /// The index of this node in the parent's children.
@@ -103,14 +120,14 @@ public class Syntax: CustomStringConvertible {
 
   /// The root of the tree in which this node resides.
   public var root: Syntax {
-    return Syntax.make(root: _root,  data: _root)
+    return makeSyntax(root: _root,  data: _root)
   }
 
   /// The sequence of indices that correspond to child nodes that are not
   /// missing.
   ///
   /// This property is an implementation detail of `SyntaxChildren`.
-  internal var presentChildIndices: PresentChildIndicesSequence {
+  internal var presentChildIndices: _SyntaxBase.PresentChildIndicesSequence {
     return raw.layout.indices.lazy.filter { self.raw.layout[$0].isPresent }
   }
 
@@ -121,7 +138,7 @@ public class Syntax: CustomStringConvertible {
   public func child(at index: Int) -> Syntax? {
     guard raw.layout.indices.contains(index) else { return nil }
     if raw.layout[index].isMissing { return nil }
-    return Syntax.make(root: _root, data: data.cachedChild(at: index))
+    return makeSyntax(root: _root, data: data.cachedChild(at: index))
   }
 
   /// A source-accurate description of this node.
@@ -130,9 +147,7 @@ public class Syntax: CustomStringConvertible {
     self.write(to: &s)
     return s
   }
-}
-
-extension Syntax: TextOutputStreamable {
+  
   /// Prints the raw value of this node to the provided stream.
   /// - Parameter stream: The stream to which to print the raw tree.
   public func write<Target>(to target: inout Target)
@@ -141,21 +156,27 @@ extension Syntax: TextOutputStreamable {
   }
 }
 
-extension Syntax: Hashable {
-  /// Determines if two nodes are equal to each other.
-  public static func ==(lhs: Syntax, rhs: Syntax) -> Bool {
-    return lhs.hashValue == rhs.hashValue
-  }
-  /// Use reference value as the hashValue for this Syntax
-  public var hashValue: Int {
-    return ObjectIdentifier(data).hashValue
-  }
+/// Determines if two nodes are equal to each other.
+public func ==(lhs: Syntax, rhs: Syntax) -> Bool {
+  return lhs.uniqueIdentifier == rhs.uniqueIdentifier
 }
 
 /// MARK: - Nodes
 
 /// A Syntax node representing a single token.
-public class TokenSyntax: Syntax {
+public struct TokenSyntax: _SyntaxBase {
+  var _root: SyntaxData
+  unowned var _data: SyntaxData 
+
+  /// Creates a Syntax node from the provided root and data.
+  internal init(root: SyntaxData, data: SyntaxData) {
+    self._root = root
+    self._data = data
+#if DEBUG
+    validate()
+#endif
+  }
+
   /// The text of the token as written in the source code.
   public var text: String {
     return tokenKind.text

tools/SwiftSyntax/SyntaxBuilders.swift.gyb

@@ -71,7 +71,7 @@ extension ${node.name} {
   ///            incrementally build the structure of the node.
   /// - Returns: A `${node.name}` with all the fields populated in the builder
   ///            closure.
-  public convenience init(_ build: (inout ${Builder}) -> Void) {
+  public init(_ build: (inout ${Builder}) -> Void) {
     var builder = ${Builder}()
     build(&builder)
     let data = builder.buildData()

tools/SwiftSyntax/SyntaxChildren.swift

@@ -15,7 +15,7 @@ import Foundation
 public struct SyntaxChildren: Sequence {
   public struct Iterator: IteratorProtocol {
     let node: Syntax
-    var indexIterator: Syntax.PresentChildIndicesSequence.Iterator
+    var indexIterator: _SyntaxBase.PresentChildIndicesSequence.Iterator
 
     init(node: Syntax) {
       self.indexIterator = node.presentChildIndices.makeIterator()

tools/SwiftSyntax/SyntaxCollection.swift

@@ -15,7 +15,19 @@ import Foundation
 /// Represents a collection of Syntax nodes of a specific type. SyntaxCollection
 /// behaves as a regular Swift collection, and has accessors that return new
 /// versions of the collection with different children.
-public class SyntaxCollection<SyntaxElement: Syntax>: Syntax {
+public class SyntaxCollection<SyntaxElement: Syntax>: _SyntaxBase {
+  var _root: SyntaxData
+  unowned var _data: SyntaxData 
+
+  /// Creates a Syntax node from the provided root and data.
+  internal init(root: SyntaxData, data: SyntaxData) {
+    self._root = root
+    self._data = data
+#if DEBUG
+    validate()
+#endif
+  }
+
   /// Creates a new SyntaxCollection by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///

tools/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -40,7 +40,7 @@ public enum SyntaxFactory {
     let data = SyntaxData(raw: .node(.unknown, 
                                      tokens.map { $0.data.raw },
                                      .present))
-    return Syntax(root: data, data: data)
+    return AnySyntax(root: data, data: data)
   }
 
 /// MARK: Syntax Node Creation APIs
@@ -64,14 +64,14 @@ public enum SyntaxFactory {
 %       end
 %     end
     ], .present))
-    return ${node.name}(root: data, data: data)
+    return ${node.swift_type_name}(root: data, data: data)
   }
 %   elif node.is_syntax_collection():
   public static func make${node.syntax_kind}(
     _ elements: [${node.collection_element_type}]) -> ${node.name} {
     let data = SyntaxData(raw: .node(.${node.swift_syntax_kind},
                                      elements.map { $0.data.raw }, .present))
-    return ${node.name}(root: data, data: data)
+    return ${node.swift_type_name}(root: data, data: data)
   }
 %   end
 
@@ -81,7 +81,7 @@ public enum SyntaxFactory {
       ${make_missing_swift_child(child)},
 %   end
     ], .present))
-    return ${node.name}(root: data, data: data)
+    return ${node.swift_type_name}(root: data, data: data)
   }
 % end
 

tools/SwiftSyntax/SyntaxKind.swift.gyb

@@ -52,30 +52,29 @@ internal enum SyntaxKind: String, Codable {
   }
 }
 
-extension Syntax {
-  /// Creates a Syntax node from the provided RawSyntax using the appropriate
-  /// Syntax type, as specified by its kind.
-  /// - Parameters:
-  ///   - raw: The raw syntax with which to create this node.
-  ///   - root: The root of this tree, or `nil` if the new node is the root.
-  static func fromRaw(_ raw: RawSyntax) -> Syntax {
-    let data = SyntaxData(raw: raw)
-    return make(root: nil, data: data)
-  }
+/// Creates a Syntax node from the provided RawSyntax using the appropriate
+/// Syntax type, as specified by its kind.
+/// - Parameters:
+///   - raw: The raw syntax with which to create this node.
+///   - root: The root of this tree, or `nil` if the new node is the root.
+internal func makeSyntax(_ raw: RawSyntax) -> Syntax {
+  let data = SyntaxData(raw: raw)
+  return makeSyntax(root: nil, data: data)
+}
 
-  /// Creates a Syntax node from the provided SyntaxData using the appropriate
-  /// Syntax type, as specified by its kind.
-  /// - Parameters:
-  ///   - root: The root of this tree, or `nil` if the new node is the root.
-  ///   - data: The data for this new node.
-  static func make(root: SyntaxData?, data: SyntaxData) -> Syntax {
-    let root = root ?? data
-    switch data.raw.kind {
-    case .token: return TokenSyntax(root: root, data: data)
-    case .unknown: return Syntax(root: root, data: data)
+/// Creates a Syntax node from the provided SyntaxData using the appropriate
+/// Syntax type, as specified by its kind.
+/// - Parameters:
+///   - root: The root of this tree, or `nil` if the new node is the root.
+///   - data: The data for this new node.
+internal func makeSyntax(root: SyntaxData?, data: SyntaxData) -> Syntax {
+  let root = root ?? data
+  switch data.raw.kind {
+  case .token: return TokenSyntax(root: root, data: data)
+  case .unknown: return AnySyntax(root: root, data: data)
 % for node in SYNTAX_NODES:
-    case .${node.swift_syntax_kind}: return ${node.name}(root: root, data: data)
+  case .${node.swift_syntax_kind}:
+    return ${node.swift_type_name}(root: root, data: data)
 % end
-    }
   }
 }