Remove AnySyntax, explicitly specialize SyntaxCollection nodes

Author: harlanhaskins

test/SwiftSyntax/SyntaxChildren.swift

@@ -28,7 +28,7 @@ var SyntaxChildrenAPI = TestSuite("SyntaxChildrenAPI")
 SyntaxChildrenAPI.test("IterateWithAllPresent") {
   let returnStmt = SyntaxFactory.makeReturnStmt(
     returnKeyword: SyntaxFactory.makeReturnKeyword(),
-    expression: SyntaxFactory.makeBlankExpr(),
+    expression: SyntaxFactory.makeBlankUnknownExpr(),
     semicolon: SyntaxFactory.makeSemicolonToken())
 
   var iterator = returnStmt.children.makeIterator()

tools/SwiftSyntax/CMakeLists.txt

@@ -14,7 +14,7 @@ add_swift_library(swiftSwiftSyntax SHARED
   Syntax.swift
   SyntaxData.swift
   SyntaxChildren.swift
-  SyntaxCollection.swift
+  SyntaxCollections.swift.gyb
   SyntaxBuilders.swift.gyb
   SyntaxFactory.swift.gyb
   SyntaxKind.swift.gyb

tools/SwiftSyntax/SyntaxCollection.swift renamed to tools/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -1,4 +1,11 @@
-//===-------------- SyntaxCollection.swift - Syntax Collection ------------===//
+%{
+  from gyb_syntax_support import *
+  # -*- mode: Swift -*-
+  # Ignore the following admonition it applies to the resulting .swift file only
+}%
+//// Automatically Generated From SyntaxCollections.swift.gyb.
+//// Do Not Edit Directly!
+//===------------ SyntaxCollections.swift.gyb - Syntax Collection ---------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -12,12 +19,15 @@
 
 import Foundation
 
+% for node in SYNTAX_NODES:
+%   if node.collection_element:
+
 /// 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>: _SyntaxBase {
+public struct ${node.name}: _SyntaxBase {
   var _root: SyntaxData
-  unowned var _data: SyntaxData 
+  unowned var _data: SyntaxData
 
   /// Creates a Syntax node from the provided root and data.
   internal init(root: SyntaxData, data: SyntaxData) {
@@ -28,52 +38,52 @@ public class SyntaxCollection<SyntaxElement: Syntax>: _SyntaxBase {
 #endif
   }
 
-  /// Creates a new SyntaxCollection by replacing the underlying layout with
+  /// Creates a new `${node.name}` by replacing the underlying layout with
   /// a different set of raw syntax nodes.
   ///
   /// - Parameter layout: The new list of raw syntax nodes underlying this
   ///                     collection.
-  /// - Returns: A new SyntaxCollection with the new layout underlying it.
+  /// - Returns: A new `${node.name}` with the new layout underlying it.
   internal func replacingLayout(
-    _ layout: [RawSyntax]) -> SyntaxCollection<SyntaxElement> {
+    _ layout: [RawSyntax]) -> ${node.name} {
     let newRaw = data.raw.replacingLayout(layout)
     let (newRoot, newData) = data.replacingSelf(newRaw)
-    return SyntaxCollection<SyntaxElement>(root: newRoot, data: newData)
+    return ${node.name}(root: newRoot, data: newData)
   }
 
-  /// Creates a new SyntaxCollection by appending the provided syntax element
+  /// Creates a new `${node.name}` by appending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to append.
-  /// - Returns: A new SyntaxCollection with that element appended to the end.
+  /// - Returns: A new `${node.name}` with that element appended to the end.
   public func appending(
-    _ syntax: SyntaxElement) -> SyntaxCollection<SyntaxElement> {
+    _ syntax: ${node.collection_element_type}) -> ${node.name} {
     var newLayout = data.raw.layout
     newLayout.append(syntax.raw)
     return replacingLayout(newLayout)
   }
 
-  /// Creates a new SyntaxCollection by prepending the provided syntax element
+  /// Creates a new `${node.name}` by prepending the provided syntax element
   /// to the children.
   ///
   /// - Parameter syntax: The element to prepend.
-  /// - Returns: A new SyntaxCollection with that element prepended to the
+  /// - Returns: A new `${node.name}` with that element prepended to the
   ///            beginning.
   public func prepending(
-    _ syntax: SyntaxElement) -> SyntaxCollection<SyntaxElement> {
+    _ syntax: ${node.collection_element_type}) -> ${node.name} {
     return inserting(syntax, at: 0)
   }
 
-  /// Creates a new SyntaxCollection by inserting the provided syntax element
+  /// Creates a new `${node.name}` by inserting the provided syntax element
   /// at the provided index in the children.
   ///
   /// - Parameters:
   ///   - syntax: The element to insert.
   ///   - index: The index at which to insert the element in the collection.
   ///
-  /// - Returns: A new SyntaxCollection with that element appended to the end.
-  public func inserting(_ syntax: SyntaxElement,
-                        at index: Int) -> SyntaxCollection<SyntaxElement> {
+  /// - Returns: A new `${node.name}` with that element appended to the end.
+  public func inserting(_ syntax: ${node.collection_element_type},
+                        at index: Int) -> ${node.name} {
     var newLayout = data.raw.layout
     /// Make sure the index is a valid insertion index (0 to 1 past the end)
     precondition((newLayout.startIndex...newLayout.endIndex).contains(index),
@@ -82,67 +92,71 @@ public class SyntaxCollection<SyntaxElement: Syntax>: _SyntaxBase {
     return replacingLayout(newLayout)
   }
 
-  /// Creates a new SyntaxCollection by removing the syntax element at the
+  /// Creates a new `${node.name}` by removing the syntax element at the
   /// provided index.
   ///
   /// - Parameter index: The index of the element to remove from the collection.
-  /// - Returns: A new SyntaxCollection with the element at the provided index
+  /// - Returns: A new `${node.name}` with the element at the provided index
   ///            removed.
-  public func removing(childAt index: Int) -> SyntaxCollection<SyntaxElement> {
+  public func removing(childAt index: Int) -> ${node.name} {
     var newLayout = data.raw.layout
     newLayout.remove(at: index)
     return replacingLayout(newLayout)
   }
 
-  /// Creates a new SyntaxCollection by removing the first element.
+  /// Creates a new `${node.name}` by removing the first element.
   ///
-  /// - Returns: A new SyntaxCollection with the first element removed.
-  public func removingFirst() -> SyntaxCollection<SyntaxElement> {
+  /// - Returns: A new `${node.name}` with the first element removed.
+  public func removingFirst() -> ${node.name} {
     var newLayout = data.raw.layout
     newLayout.removeFirst()
     return replacingLayout(newLayout)
   }
 
-  /// Creates a new SyntaxCollection by removing the last element.
+  /// Creates a new `${node.name}` by removing the last element.
   ///
-  /// - Returns: A new SyntaxCollection with the last element removed.
-  public func removingLast() -> SyntaxCollection<SyntaxElement> {
+  /// - Returns: A new `${node.name}` with the last element removed.
+  public func removingLast() -> ${node.name} {
     var newLayout = data.raw.layout
     newLayout.removeLast()
     return replacingLayout(newLayout)
   }
 
   /// Returns an iterator over the elements of this syntax collection.
-  public func makeIterator() -> SyntaxCollectionIterator<SyntaxElement> {
-    return SyntaxCollectionIterator(collection: self)
+  public func makeIterator() -> ${node.name}Iterator {
+    return ${node.name}Iterator(collection: self)
   }
 }
 
-/// Conformance for SyntaxCollection to the Collection protocol.
-extension SyntaxCollection: Collection {
+/// Conformance for `${node.name}`` to the Collection protocol.
+extension ${node.name}: Collection {
   public var startIndex: Int {
     return data.childCaches.startIndex
   }
-  
+
   public var endIndex: Int {
     return data.childCaches.endIndex
   }
-  
+
   public func index(after i: Int) -> Int {
     return data.childCaches.index(after: i)
   }
-  
-  public subscript(_ index: Int) -> SyntaxElement {
-    return child(at: index)! as! SyntaxElement
+
+  public subscript(_ index: Int) -> ${node.collection_element_type} {
+%   cast = '' if node.collection_element_type == 'Syntax' \
+%          else 'as! ' + node.collection_element_type
+    return child(at: index)! ${cast}
   }
 }
 
-/// A type that iterates over a syntax collection using its indices.
-public struct SyntaxCollectionIterator<Element: Syntax>: IteratorProtocol {
-  private let collection: SyntaxCollection<Element>
-  private var index: SyntaxCollection<Element>.Index
+/// A type that iterates over a `${node.name}` using its indices.
+public struct ${node.name}Iterator: IteratorProtocol {
+  public typealias Element = ${node.collection_element_type}
+
+  private let collection: ${node.name}
+  private var index: ${node.name}.Index
 
-  fileprivate init(collection: SyntaxCollection<Element>) {
+  fileprivate init(collection: ${node.name}) {
     self.collection = collection
     self.index = collection.startIndex
   }
@@ -160,3 +174,5 @@ public struct SyntaxCollectionIterator<Element: Syntax>: IteratorProtocol {
   }
 }
 
+%   end
+% end

tools/SwiftSyntax/SyntaxFactory.swift.gyb

@@ -40,13 +40,15 @@ public enum SyntaxFactory {
     let data = SyntaxData(raw: .node(.unknown, 
                                      tokens.map { $0.data.raw },
                                      .present))
-    return AnySyntax(root: data, data: data)
+    return UnknownSyntax(root: data, data: data)
   }
 
 /// MARK: Syntax Node Creation APIs
 
 % for node in SYNTAX_NODES:
-%   if node.children:
+%   if node.is_base():
+%     pass
+%   elif node.children:
 %     child_params = []
 %     for child in node.children:
 %         param_type = child.type_name
@@ -64,25 +66,27 @@ public enum SyntaxFactory {
 %       end
 %     end
     ], .present))
-    return ${node.swift_type_name}(root: data, data: data)
+    return ${node.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.swift_type_name}(root: data, data: data)
+    return ${node.name}(root: data, data: data)
   }
 %   end
 
+%   if not node.is_base():
   public static func makeBlank${node.syntax_kind}() -> ${node.name} {
     let data = SyntaxData(raw: .node(.${node.swift_syntax_kind}, [
-%   for child in node.children:
+%     for child in node.children:
       ${make_missing_swift_child(child)},
-%   end
+%     end
     ], .present))
-    return ${node.swift_type_name}(root: data, data: data)
+    return ${node.name}(root: data, data: data)
   }
+%   end
 % end
 
 /// MARK: Token Creation APIs

tools/SwiftSyntax/SyntaxKind.swift.gyb

@@ -71,10 +71,14 @@ 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)
+  case .unknown: return UnknownSyntax(root: root, data: data)
 % for node in SYNTAX_NODES:
   case .${node.swift_syntax_kind}:
-    return ${node.swift_type_name}(root: root, data: data)
+%   if node.is_base():
+    return Unknown${node.name}(root: root, data: data)
+%   else:
+    return ${node.name}(root: root, data: data)
+%   end
 % end
   }
 }

tools/SwiftSyntax/SyntaxNodes.swift.gyb

@@ -38,51 +38,28 @@ Each node will have:
 """
 }%
 
-public struct AnySyntax: _SyntaxBase, Hashable {
+/// A wrapper around a raw Syntax layout.
+public struct UnknownSyntax: _SyntaxBase {
   var _root: SyntaxData
-  unowned var _data: SyntaxData
+  unowned var _data: SyntaxData 
 
-  /// Creates an `AnySyntax`` node from the provided root and data.
+  /// Creates an `UnknownSyntax` node from the provided root and data.
   internal init(root: SyntaxData, data: SyntaxData) {
     self._root = root
     self._data = data
-  }
-  
-  public static func ==(lhs: AnySyntax, rhs: AnySyntax) -> Bool {
-    return lhs._data === rhs._data
-  }
-
-  public var hashValue: Int {
-    return ObjectIdentifier(_data).hashValue
+#if DEBUG
+    validate()
+#endif
   }
 }
 
 % for node in SYNTAX_NODES:
 %   base_type = node.base_type
 %   if node.is_base():
 public protocol ${node.name}: Syntax {}
-public struct ${node.swift_type_name}: ${node.name}, _SyntaxBase, Hashable {
-  var _root: SyntaxData
-  unowned var _data: SyntaxData
-
-  /// Creates an `${node.swift_type_name}` node from the provided root and data.
-  internal init(root: SyntaxData, data: SyntaxData) {
-    self._root = root
-    self._data = data
-  }
-
-  public static func ==(lhs: ${node.swift_type_name},
-                        rhs: ${node.swift_type_name}) -> Bool {
-    return lhs._data === rhs._data
-  }
-
-  public var hashValue: Int {
-    return ObjectIdentifier(_data).hashValue
-  }
-}
 
 %   elif node.collection_element:
-public typealias ${node.name} = SyntaxCollection<${node.swift_collection_element_type}>
+%     pass
 %   else:
 public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
 %     if node.children:
@@ -141,18 +118,21 @@ public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
 #endif
 %     end
 %     for child in node.children:
+%       ret_type = child.type_name
+%       cast_symbol = 'as!'
+%       if child.is_optional:
+%         ret_type += '?'
+%         cast_symbol = 'as?'
+%       end
+%       cast = '' if child.type_name == 'Syntax' \
+%                 else '%s %s' % (cast_symbol, child.type_name)
+  public var ${child.swift_name}: ${ret_type} {
 %       if child.is_optional:
-  public var ${child.swift_name}: ${child.swift_type_name}? {
     guard raw[Cursor.${child.swift_name}].isPresent else { return nil }
-    return ${child.swift_type_name}(root: _root,
-      data: data.cachedChild(at: Cursor.${child.swift_name}))
-  }
-%       else:
-  public var ${(child.swift_name)}: ${child.swift_type_name} {
-    return ${child.swift_type_name}(root: _root,
-      data: data.cachedChild(at: Cursor.${child.swift_name}))
-  }
 %       end
+    let child = data.cachedChild(at: Cursor.${child.swift_name})
+    return makeSyntax(root: _root, data: child) ${cast}
+  }
 %       child_node = NODE_MAP.get(child.syntax_kind)
 %       if child_node and child_node.is_syntax_collection():
 %         child_elt = child_node.collection_element_name
@@ -167,16 +147,15 @@ public struct ${node.name}: ${base_type}, _SyntaxBase, Hashable {
 %       end
 
   public func with${child.name}(
-    _ newChild: ${child.swift_type_name}?) -> ${node.name} {
+    _ newChild: ${child.type_name}?) -> ${node.name} {
     let raw = newChild?.raw ?? ${make_missing_swift_child(child)}
     let (root, newData) = data.replacingChild(raw,
                                               at: Cursor.${child.swift_name})
     return ${node.name}(root: root, data: newData)
   }
 %     end
 
-  public static func ==(lhs: ${node.swift_type_name},
-                        rhs: ${node.swift_type_name}) -> Bool {
+  public static func ==(lhs: ${node.name}, rhs: ${node.name}) -> Bool {
     return lhs._data === rhs._data
   }