Merge pull request #1103 from bnbarham/add-detach

Add a `detach()` to syntax nodes

Author: bnbarham

Sources/SwiftParser/Parser+Entry.swift.gyb

@@ -51,7 +51,8 @@ public protocol SyntaxParseable: SyntaxProtocol {
 extension ${node.name}: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.${node.parser_function}()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 

Sources/SwiftParser/gyb_generated/Parser+Entry.swift

@@ -44,70 +44,80 @@ public protocol SyntaxParseable: SyntaxProtocol {
 extension DeclSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseDeclaration()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension ExprSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseExpression()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension StmtSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseStatement()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension TypeSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseType()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension PatternSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parsePattern()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension MemberDeclBlockSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseMemberDeclList()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension SourceFileSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseSourceFile()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension SwitchCaseSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseSwitchCase()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension CatchClauseSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseCatchClause()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 
 extension GenericParameterClauseSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     let node = parser.parseGenericParameters()
-    return parser.parseRemainder(into: node).syntax
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw).cast(Self.self)
   }
 }
 

Sources/SwiftSyntax/Raw/RawSyntaxNodeProtocol.swift

@@ -65,7 +65,7 @@ extension RawSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawTokenSyntax: RawSyntaxToSyntax, RawSyntaxNodeProtocol {
+public struct RawTokenSyntax: RawSyntaxNodeProtocol {
   public typealias SyntaxType = TokenSyntax
 
   @_spi(RawSyntax)
@@ -225,24 +225,3 @@ public struct RawTokenSyntax: RawSyntaxToSyntax, RawSyntaxNodeProtocol {
     )
   }
 }
-
-/// Provides the `Syntax` type that a RawSyntax node represents.
-/// All syntax nodes conform to this protocol.
-/// We cannot add `SyntaxType` to `RawSyntaxNodeProtocol` because then
-/// `RawSyntaxNodeProtocol` has associated type requirements, which limits the
-/// places that `RawSyntaxNodeProtocol` can be used.
-@_spi(RawSyntax)
-public protocol RawSyntaxToSyntax: RawSyntaxNodeProtocol {
-  associatedtype SyntaxType: SyntaxProtocol
-}
-
-// TODO: Is it worth having this?
-// The only place that should be using it is the parser, which only converts
-// to `Syntax` in a few places anyway - we could just do the case there.
-@_spi(RawSyntax)
-public extension RawSyntaxToSyntax {
-  /// Realizes a `Syntax` node for this `RawSyntax` node.
-  var syntax: SyntaxType {
-    return Syntax(raw: raw).cast(SyntaxType.self)
-  }
-}

Sources/SwiftSyntax/Raw/RawSyntaxNodes.swift.gyb

@@ -28,7 +28,7 @@ public protocol Raw${node.name}NodeProtocol: Raw${node.base_type}NodeProtocol {}
 % for node in SYNTAX_NODES:
 
 @_spi(RawSyntax)
-public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_type}NodeProtocol, RawSyntaxToSyntax {
+public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_type}NodeProtocol {
 %   enums = []
 %   for child in node.children:
 %     if child.node_choices:
@@ -69,7 +69,6 @@ public struct Raw${node.name}: Raw${node.name if node.is_base() else node.base_t
   }
 
 %   end
-  public typealias SyntaxType = ${node.name}
 
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {