Prevent Unrelated Casts on Child Choice Node

Author: Matejkob

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxCollectionsFile.swift

@@ -112,6 +112,11 @@ let syntaxCollectionsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
             StmtSyntax("return .choices(\(choices))")
           }
+
+          for choiceNodeName in node.elementChoices {
+            let choiceNode = SYNTAX_NODE_MAP[choiceNodeName]!
+            choiceNodeCastingMethods(for: choiceNode.kind)
+          }
         }
       }
 

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodeCasting.swift

@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SyntaxSupport
+
+@MemberBlockItemListBuilder
+func choiceNodeCastingMethods(for syntaxNodeKind: SyntaxNodeKind) -> MemberBlockItemListSyntax {
+  if syntaxNodeKind.isBase {
+    DeclSyntax(
+      """
+      /// Checks if the current syntax node can be cast to the type conforming to the ``\(syntaxNodeKind.protocolType)`` protocol.
+      ///
+      /// - Returns: `true` if the node can be cast, `false` otherwise.
+      public func `is`<S: \(syntaxNodeKind.protocolType)>(_ syntaxType: S.Type) -> Bool {
+        return self.as(syntaxType) != nil
+      }
+      """
+    )
+
+    DeclSyntax(
+      """
+      /// Attempts to cast the current syntax node to the type conforming to the ``\(syntaxNodeKind.protocolType)`` protocol.
+      ///
+      /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
+      public func `as`<S: \(syntaxNodeKind.protocolType)>(_ syntaxType: S.Type) -> S? {
+        return S.init(self)
+      }
+      """
+    )
+
+    DeclSyntax(
+      """
+      /// Force-casts the current syntax node to the type conforming to the ``\(syntaxNodeKind.protocolType)`` protocol.
+      ///
+      /// - Returns: An instance of the specialized type.
+      /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+      public func cast<S: \(syntaxNodeKind.protocolType)>(_ syntaxType: S.Type) -> S {
+        return self.as(S.self)!
+      }
+      """
+    )
+  } else {
+    DeclSyntax(
+      """
+      /// Checks if the current syntax node can be cast to ``\(syntaxNodeKind.syntaxType)``.
+      ///
+      /// - Returns: `true` if the node can be cast, `false` otherwise.
+      public func `is`(_ syntaxType: \(syntaxNodeKind.syntaxType).Type) -> Bool {
+        return self.as(syntaxType) != nil
+      }
+      """
+    )
+
+    DeclSyntax(
+      """
+      /// Attempts to cast the current syntax node to ``\(syntaxNodeKind.syntaxType)``.
+      ///
+      /// - Returns: An instance of ``\(syntaxNodeKind.syntaxType)``, or `nil` if the cast fails.
+      public func `as`(_ syntaxType: \(syntaxNodeKind.syntaxType).Type) -> \(syntaxNodeKind.syntaxType)? {
+        return \(syntaxNodeKind.syntaxType).init(self)
+      }
+      """
+    )
+
+    DeclSyntax(
+      """
+      /// Force-casts the current syntax node to ``\(syntaxNodeKind.syntaxType)``.
+      ///
+      /// - Returns: An instance of ``\(syntaxNodeKind.syntaxType)``.
+      /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+      public func cast(_ syntaxType: \(syntaxNodeKind.syntaxType).Type) -> \(syntaxNodeKind.syntaxType) {
+        return self.as(\(syntaxNodeKind.syntaxType).self)!
+      }
+      """
+    )
+  }
+}

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift

@@ -289,5 +289,9 @@ private func generateSyntaxChildChoices(for child: Child) throws -> EnumDeclSynt
 
       StmtSyntax("return .choices(\(choices))")
     }
+
+    for choiceNode in choices {
+      choiceNodeCastingMethods(for: choiceNode.syntaxNodeKind)
+    }
   }
 }

Release Notes/510.md

@@ -49,6 +49,11 @@
   - Description: `is`, `as`, and `cast` methods on base node protocols with base-type conversions are marked as deprecated. The deprecated methods emit a warning that informs the developer that the cast will always succeed and should be done using the base node's initializer.
   - Issue: https://github.com/apple/swift-syntax/issues/2092
   - Pull Request: https://github.com/apple/swift-syntax/pull/2108
+  
+- Child Choice Node Casts
+  - Description: `is`, `as`, and `cast` methods for types not contained in the choice node are marked as deprecated. The deprecated methods will emit a warning, indicating that the cast will always fail.
+  - Issue: https://github.com/apple/swift-syntax/issues/2092
+  - Pull Request: https://github.com/apple/swift-syntax/pull/2184
 
 ## API-Incompatible Changes
 

Sources/SwiftSyntax/SyntaxProtocol.swift

@@ -698,3 +698,38 @@ public extension SyntaxProtocol {
 /// Protocol for the enums nested inside ``Syntax`` nodes that enumerate all the
 /// possible types a child node might have.
 public protocol SyntaxChildChoices: SyntaxProtocol {}
+
+public extension SyntaxChildChoices {
+
+  /// Checks if the current ``SyntaxChildChoices`` instance can be cast to a given specialized syntax type.
+  ///
+  /// - Returns: `true` if the node can be cast, `false` otherwise.
+  ///
+  /// - Note: This method is marked as deprecated because it is advised not to use it for unrelated casts.
+  @available(*, deprecated, message: "This cast will always fail")
+  func `is`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
+    return self.as(syntaxType) != nil
+  }
+
+  /// Attempts to cast the current ``SyntaxChildChoices`` instance to a given specialized syntax type.
+  ///
+  /// - Returns: An instance of the specialized syntax type, or `nil` if the cast fails.
+  ///
+  /// - Note: This method is marked as deprecated because it is advised not to use it for unrelated casts.
+  @available(*, deprecated, message: "This cast will always fail")
+  func `as`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+    return S.init(self)
+  }
+
+  /// Force-casts the current ``SyntaxChildChoices`` instance to a given specialized syntax type.
+  ///
+  /// - Returns: An instance of the specialized syntax type.
+  ///
+  /// - Warning: This function will crash if the cast is not possible. Use `as` for a safe attempt.
+  ///
+  /// - Note: This method is marked as deprecated because it is advised not to use it for unrelated casts.
+  @available(*, deprecated, message: "This cast will always fail")
+  func cast<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S {
+    return self.as(S.self)!
+  }
+}