Remove 'SyntaxProtocol.syntaxNodeType' requirement

Instead, provide it in `extension SyntaxProtocol`.
Also, avoid creating existential or checking dynamic type for it. It can
be statically determined by the `SyntaxKind`.

Author: rintaro

Sources/SwiftSyntax/Misc.swift.gyb

@@ -61,3 +61,15 @@ extension Syntax {
     }
   }
 }
+
+extension SyntaxKind {
+  var syntaxNodeType: SyntaxProtocol.Type {
+    switch self {
+    case .token: return TokenSyntax.self
+    case .unknown: return UnknownSyntax.self
+% for node in NON_BASE_SYNTAX_NODES:
+    case .${node.swift_syntax_kind}: return ${node.name}.self
+% end
+    }
+  }
+}

Sources/SwiftSyntax/Syntax.swift

@@ -67,10 +67,6 @@ extension Syntax {
   public func `as`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(self)
   }
-
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return Swift.type(of: self.asProtocol(SyntaxProtocol.self))
-  }
 }
 
 extension Syntax: CustomReflectable {
@@ -113,9 +109,6 @@ public protocol SyntaxProtocol: CustomStringConvertible,
   /// Converts the given `Syntax` node to this type. Returns `nil` if the
   /// conversion is not possible.
   init?(_ syntaxNode: Syntax)
-
-  /// Returns the underlying syntax node type.
-  var syntaxNodeType: SyntaxProtocol.Type { get }
 }
 
 extension SyntaxProtocol {
@@ -128,6 +121,10 @@ extension SyntaxProtocol {
   public var raw: RawSyntax {
     return _syntaxNode.data.raw
   }
+
+  public var syntaxNodeType: SyntaxProtocol.Type {
+    return self.raw.kind.syntaxNodeType
+  }
 }
 
 public extension SyntaxProtocol {

Sources/SwiftSyntax/SyntaxBaseNodes.swift.gyb

@@ -99,10 +99,6 @@ public struct ${node.name}: ${node.name}Protocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: ${node.name}Protocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }

Sources/SwiftSyntax/SyntaxCollections.swift.gyb

@@ -66,10 +66,6 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
     self.init(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return Swift.type(of: self)
-  }
-
   /// The number of elements, `present` or `missing`, in this collection.
   public var count: Int { return raw.layoutView!.children.count }
 

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -95,10 +95,6 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
     let data = SyntaxData.forRoot(raw)
     self.init(data)
   }
-
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return Swift.type(of: self)
-  }
 %     for (idx, child) in enumerate(node.children):
 %       child_node = NODE_MAP.get(child.syntax_kind)
 %

Sources/SwiftSyntax/SyntaxOtherNodes.swift

@@ -25,10 +25,6 @@ public struct UnknownSyntax: SyntaxProtocol, SyntaxHashable {
     self._syntaxNode = syntax
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return Swift.type(of: self)
-  }
-
   /// 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 +89,6 @@ public struct TokenSyntax: SyntaxProtocol, SyntaxHashable {
     self.init(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return Swift.type(of: self)
-  }
-
   public var presence: SourcePresence {
     return tokenView.presence
   }

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -80,10 +80,6 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: DeclSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }
@@ -183,10 +179,6 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: ExprSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }
@@ -286,10 +278,6 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: StmtSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }
@@ -389,10 +377,6 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: TypeSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }
@@ -492,10 +476,6 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
     self._syntaxNode = Syntax(data)
   }
 
-  public var syntaxNodeType: SyntaxProtocol.Type {
-    return _syntaxNode.syntaxNodeType
-  }
-
   public func `is`<S: PatternSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
     return self.as(syntaxType) != nil
   }