Add casting methods to protocols

These return the non type-erased types of a node if it conforms to the
given protocol and nil otherwise.

With these methods returning the non type-erased type we can get rid of
_asConcreteType.

Author: ahoppen

Changelog.md

@@ -101,6 +101,15 @@ For increased performance, the modelling of the syntax node hierarchy has been s
   exprSyntax.is(IdentifierExprSyntax.self)
   ```
 
+- To retrieve the non-type erased version of a type, use the `as(_: SyntaxProtocol.self)` method
+
+  ```swift
+  let identifierExprSyntax: IdentifierExprSyntax = /* ... */
+  let node = Syntax(identifierExprSyntax)
+  node.as(SyntaxProtocol.self) // returns a IdentifierExprSyntax with static type SyntaxProtocol
+  node.as(ExprSyntaxProtocol.self) // returns a IdentifierExprSyntax with static type ExprSyntaxProtocol?
+  ```
+
 
 - Downcasting can no longer be performed using the `as` operator. For downcasting use the `as(_: SyntaxProtocol)` method on any type eraser. ([#155](https://github.com/apple/swift-syntax/pull/155))
 

Sources/SwiftSyntax/Misc.swift.gyb

@@ -39,10 +39,16 @@ extension SyntaxNode {
 % end
 }
 
-public extension Syntax {
-  /// Retrieve the concretely typed node that this Syntax node wraps.
-  /// This property is exposed for testing purposes only.
-  var _asConcreteType: Any {
+extension Syntax {
+  /// Syntax nodes always conform to SyntaxProtocol. This API is just added
+  /// for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: SyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: SyntaxProtocol.Protocol) -> SyntaxProtocol {
     switch self.as(SyntaxEnum.self) {
     case .token(let node):
       return node

Sources/SwiftSyntax/Syntax.swift

@@ -53,7 +53,7 @@ extension Syntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: self._asConcreteType)
+    return Mirror(reflecting: self.as(SyntaxProtocol.self))
   }
 }
 

Sources/SwiftSyntax/SyntaxBaseNodes.swift.gyb

@@ -29,6 +29,20 @@
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol ${node.name}Protocol: ${base_type}Protocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// ${node.name}Protocol. 
+  func `is`(_: ${node.name}Protocol.Protocol) -> Bool {
+    return self.as(${node.name}Protocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// ${node.name}Protocol. Otherwise return nil.
+  func `as`(_: ${node.name}Protocol.Protocol) -> ${node.name}Protocol? {
+    return self.as(SyntaxProtocol.self) as? ${node.name}Protocol
+  }
+}
+
 %     for line in dedented_lines(node.description):
 /// ${line}
 %     end
@@ -83,13 +97,25 @@ public struct ${node.name}: ${node.name}Protocol, SyntaxHashable {
   public func `as`<S: ${node.name}Protocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `${node.name}Protocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: ${node.name}Protocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: ${node.name}Protocol.Protocol) -> ${node.name}Protocol {
+    return Syntax(self).as(${node.name}Protocol.self)!
+  }
 }
 
 extension ${node.name}: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }
 

Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

@@ -162,9 +162,9 @@ extension ${node.name}: CustomReflectable {
     return Mirror(self, children: [
 %     for child in node.children:
 %       if child.is_optional:
-      "${child.swift_name}": ${child.swift_name}.map(Syntax.init)?._asConcreteType as Any,
+      "${child.swift_name}": ${child.swift_name}.map(Syntax.init)?.as(SyntaxProtocol.self) as Any,
 %       else:
-      "${child.swift_name}": Syntax(${child.swift_name})._asConcreteType,
+      "${child.swift_name}": Syntax(${child.swift_name}).as(SyntaxProtocol.self),
 %       end
 %     end
     ])

Sources/SwiftSyntax/SyntaxTraits.swift.gyb

@@ -20,6 +20,8 @@
 //===----------------------------------------------------------------------===//
 
 % for trait in TRAITS:
+// MARK: - ${trait.trait_name}Syntax
+
 public protocol ${trait.trait_name}Syntax: SyntaxProtocol {
 % for child in trait.children:
 %   ret_type = child.type_name
@@ -30,6 +32,21 @@ public protocol ${trait.trait_name}Syntax: SyntaxProtocol {
   func with${child.name}(_ newChild: ${child.type_name}?) -> Self
 % end
 }
+
+public extension SyntaxProtocol {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// `${trait.trait_name}Syntax`. 
+  func `is`(_: ${trait.trait_name}Syntax.Protocol) -> Bool {
+    return self.as(${trait.trait_name}Syntax.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// `${trait.trait_name}Syntax`. Otherwise return `nil`.
+  func `as`(_: ${trait.trait_name}Syntax.Protocol) -> ${trait.trait_name}Syntax? {
+    return Syntax(self).as(SyntaxProtocol.self) as? ${trait.trait_name}Syntax
+  }
+}
+
 % end
 
 % for node in SYNTAX_NODES:

Sources/SwiftSyntax/gyb_generated/Misc.swift

@@ -1348,10 +1348,16 @@ extension SyntaxNode {
   }
 }
 
-public extension Syntax {
-  /// Retrieve the concretely typed node that this Syntax node wraps.
-  /// This property is exposed for testing purposes only.
-  var _asConcreteType: Any {
+extension Syntax {
+  /// Syntax nodes always conform to SyntaxProtocol. This API is just added
+  /// for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: SyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: SyntaxProtocol.Protocol) -> SyntaxProtocol {
     switch self.as(SyntaxEnum.self) {
     case .token(let node):
       return node

Sources/SwiftSyntax/gyb_generated/SyntaxBaseNodes.swift

@@ -19,6 +19,20 @@
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol DeclSyntaxProtocol: SyntaxProtocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// DeclSyntaxProtocol. 
+  func `is`(_: DeclSyntaxProtocol.Protocol) -> Bool {
+    return self.as(DeclSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// DeclSyntaxProtocol. Otherwise return nil.
+  func `as`(_: DeclSyntaxProtocol.Protocol) -> DeclSyntaxProtocol? {
+    return self.as(SyntaxProtocol.self) as? DeclSyntaxProtocol
+  }
+}
+
 public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
@@ -64,13 +78,25 @@ public struct DeclSyntax: DeclSyntaxProtocol, SyntaxHashable {
   public func `as`<S: DeclSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `DeclSyntaxProtocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: DeclSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: DeclSyntaxProtocol.Protocol) -> DeclSyntaxProtocol {
+    return Syntax(self).as(DeclSyntaxProtocol.self)!
+  }
 }
 
 extension DeclSyntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }
 
@@ -81,6 +107,20 @@ extension DeclSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol ExprSyntaxProtocol: SyntaxProtocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// ExprSyntaxProtocol. 
+  func `is`(_: ExprSyntaxProtocol.Protocol) -> Bool {
+    return self.as(ExprSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// ExprSyntaxProtocol. Otherwise return nil.
+  func `as`(_: ExprSyntaxProtocol.Protocol) -> ExprSyntaxProtocol? {
+    return self.as(SyntaxProtocol.self) as? ExprSyntaxProtocol
+  }
+}
+
 public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
@@ -126,13 +166,25 @@ public struct ExprSyntax: ExprSyntaxProtocol, SyntaxHashable {
   public func `as`<S: ExprSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `ExprSyntaxProtocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: ExprSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: ExprSyntaxProtocol.Protocol) -> ExprSyntaxProtocol {
+    return Syntax(self).as(ExprSyntaxProtocol.self)!
+  }
 }
 
 extension ExprSyntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }
 
@@ -143,6 +195,20 @@ extension ExprSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol StmtSyntaxProtocol: SyntaxProtocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// StmtSyntaxProtocol. 
+  func `is`(_: StmtSyntaxProtocol.Protocol) -> Bool {
+    return self.as(StmtSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// StmtSyntaxProtocol. Otherwise return nil.
+  func `as`(_: StmtSyntaxProtocol.Protocol) -> StmtSyntaxProtocol? {
+    return self.as(SyntaxProtocol.self) as? StmtSyntaxProtocol
+  }
+}
+
 public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
@@ -188,13 +254,25 @@ public struct StmtSyntax: StmtSyntaxProtocol, SyntaxHashable {
   public func `as`<S: StmtSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `StmtSyntaxProtocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: StmtSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: StmtSyntaxProtocol.Protocol) -> StmtSyntaxProtocol {
+    return Syntax(self).as(StmtSyntaxProtocol.self)!
+  }
 }
 
 extension StmtSyntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }
 
@@ -205,6 +283,20 @@ extension StmtSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol TypeSyntaxProtocol: SyntaxProtocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// TypeSyntaxProtocol. 
+  func `is`(_: TypeSyntaxProtocol.Protocol) -> Bool {
+    return self.as(TypeSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// TypeSyntaxProtocol. Otherwise return nil.
+  func `as`(_: TypeSyntaxProtocol.Protocol) -> TypeSyntaxProtocol? {
+    return self.as(SyntaxProtocol.self) as? TypeSyntaxProtocol
+  }
+}
+
 public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
@@ -250,13 +342,25 @@ public struct TypeSyntax: TypeSyntaxProtocol, SyntaxHashable {
   public func `as`<S: TypeSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `TypeSyntaxProtocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: TypeSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: TypeSyntaxProtocol.Protocol) -> TypeSyntaxProtocol {
+    return Syntax(self).as(TypeSyntaxProtocol.self)!
+  }
 }
 
 extension TypeSyntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }
 
@@ -267,6 +371,20 @@ extension TypeSyntax: CustomReflectable {
 /// DO NOT CONFORM TO THIS PROTOCOL YOURSELF!
 public protocol PatternSyntaxProtocol: SyntaxProtocol {}
 
+public extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to 
+  /// PatternSyntaxProtocol. 
+  func `is`(_: PatternSyntaxProtocol.Protocol) -> Bool {
+    return self.as(PatternSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to 
+  /// PatternSyntaxProtocol. Otherwise return nil.
+  func `as`(_: PatternSyntaxProtocol.Protocol) -> PatternSyntaxProtocol? {
+    return self.as(SyntaxProtocol.self) as? PatternSyntaxProtocol
+  }
+}
+
 public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   public let _syntaxNode: Syntax
 
@@ -312,13 +430,25 @@ public struct PatternSyntax: PatternSyntaxProtocol, SyntaxHashable {
   public func `as`<S: PatternSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
     return S.init(_syntaxNode)
   }
+
+  /// Syntax nodes always conform to `PatternSyntaxProtocol`. This API is just
+  /// added for consistency.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func `is`(_: PatternSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  public func `as`(_: PatternSyntaxProtocol.Protocol) -> PatternSyntaxProtocol {
+    return Syntax(self).as(PatternSyntaxProtocol.self)!
+  }
 }
 
 extension PatternSyntax: CustomReflectable {
   /// Reconstructs the real syntax type for this type from the node's kind and
   /// provides a mirror that reflects this type.
   public var customMirror: Mirror {
-    return Mirror(reflecting: Syntax(self)._asConcreteType)
+    return Mirror(reflecting: Syntax(self).as(SyntaxProtocol.self))
   }
 }