Casts to children of SyntaxProtocol are not always invalid

Update these overrides so they don't always fail.

Author: bnbarham

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

@@ -79,9 +79,6 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         /// Checks if the current syntax node can be upcast to its base node type (``\#(node.kind.syntaxType)``).
         ///
         /// - Returns: `true` since the node can always be upcast to its base node.
-        ///
-        /// - Note: This method overloads the general `is` method and is marked deprecated to produce a warning
-        ///         informing the user that the upcast will always succeed.
         @available(*, deprecated, message: "This cast will always succeed")
         public func `is`(_ syntaxType: \#(node.kind.syntaxType).Type) -> Bool {
           return true
@@ -90,9 +87,6 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         /// Attempts to upcast the current syntax node to its base node type (``\#(node.kind.syntaxType)``).
         ///
         /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type.
-        ///
-        /// - Note: This method overloads the general `as` method and is marked deprecated to produce a warning
-        ///         informing the user the upcast should be performed using the target base node's initializer.
         @available(*, deprecated, message: "Use `\#(node.kind.syntaxType).init` for upcasting")
         public func `as`(_ syntaxType: \#(node.kind.syntaxType).Type) -> \#(node.kind.syntaxType)? {
           return \#(node.kind.syntaxType)(self)
@@ -101,46 +95,50 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
         /// Force-upcast the current syntax node to its base node type (``\#(node.kind.syntaxType)``).
         ///
         /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type.
-        ///
-        /// - Note: This method overloads the general `as` method and is marked deprecated to produce a warning
-        ///         informing the user the upcast should be performed using the target base node's initializer.
         @available(*, deprecated, message: "Use `\#(node.kind.syntaxType).init` for upcasting")
         public func cast(_ syntaxType: \#(node.kind.syntaxType).Type) -> \#(node.kind.syntaxType) {
           return \#(node.kind.syntaxType)(self)
         }
 
-        /// Checks if the current syntax node can be cast to a given node type from the different base node protocol hierarchy than ``\#(node.kind.protocolType)``.
+        /// Checks if the current syntax node can be cast to a given node type from a base node protocol hierarchy other
+        /// than ``\#(node.kind.protocolType)``.
         ///
-        /// - Returns: `false` since the node can not be cast to the node type from different base node protocol hierarchy than ``\#(node.kind.protocolType)``.
+        /// - Returns: `true` if the node can be cast, `false` otherwise.
         ///
-        /// - Note: This method overloads the general `is` method and is marked as deprecated to produce a warning,
-        ///         informing the user that the cast will always fail.
-        @available(*, deprecated, message: "This cast will always fail")
+        /// - Note: This generally does not make sense to call - if in a generic ``SyntaxProtocol`` context, use
+        /// ``\#(node.kind.protocolType)`` instead. Otherwise this must be a node outside of ``\#(node.kind.protocolType)``,
+        /// in which case this call will always fail.
+        @available(*, deprecated, message: "Type should be part of the '\#(node.kind.protocolType)' hierarchy")
         public func `is`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
-          return false
+          return self.as(syntaxType) != nil
         }
 
-        /// Attempts to cast the current syntax node to a given node type from the different base node protocol hierarchy than ``\#(node.kind.protocolType)``.
+        /// Attempts to cast the current syntax node to a given node type from the a base node protocol hierarchy other than
+        /// ``\#(node.kind.protocolType)``.
         ///
-        /// - Returns: `nil` since the node can not be cast to the node type from different base node protocol hierarchy than ``\#(node.kind.protocolType)``.
+        /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
         ///
-        /// - Note: This method overloads the general `as` method and is marked as deprecated to produce a warning,
-        ///         informing the user that the cast will always fail.
-        @available(*, deprecated, message: "This cast will always fail")
+        /// - Note: This generally does not make sense to call - if in a generic ``SyntaxProtocol`` context, use
+        /// ``\#(node.kind.protocolType)`` instead. Otherwise this must be a node outside of ``\#(node.kind.protocolType)``,
+        /// in which case this cast will always return `nil`.
+        @available(*, deprecated, message: "Type should be part of the '\#(node.kind.protocolType)' hierarchy")
         public func `as`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S? {
-          return nil
+          return S.init(self)
         }
 
-        /// Force-casts the current syntax node to a given node type from the different base node protocol hierarchy than ``\#(node.kind.protocolType)``.
+        /// Force-casts the current syntax node to a given node type from a base node protocol hierarchy other than
+        /// ``\#(node.kind.protocolType)``.
         ///
         /// - Returns: This method will always trigger a runtime crash and never return.
         ///
-        /// - Note: This method overloads the general `cast` method and is marked as deprecated to produce a warning,
-        ///         informing the user that the cast will always fail.
-        /// - Warning: Invoking this method will lead to a fatal error.
-        @available(*, deprecated, message: "This cast will always fail")
+        /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+        ///
+        /// - Note: This generally does not make sense to call - if in a generic ``SyntaxProtocol`` context, use
+        /// ``\#(node.kind.protocolType)`` instead. Otherwise this must be a node outside of ``\#(node.kind.protocolType)``,
+        /// in which case this cast will always crash.
+        @available(*, deprecated, message: "Type should be part of the '\#(node.kind.protocolType)' hierarchy")
         public func cast<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S {
-          fatalError("\(Self.self) cannot be cast to \(S.self)")
+          return self.as(S.self)!
         }
       }
       """#