How to use testDeclaredType_parsesChainedThrowingFunctionTypes method of DeclaredTypeTests class

...185    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Function(() throws -> DeclaredType(Single(Bool)))))")186    XCTAssert(actual.isFunction)187  }188  189  func testDeclaredType_parsesChainedThrowingFunctionTypes() {190    let actual = DeclaredType(from: "() throws -> () throws -> Bool")191    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Function(() throws -> DeclaredType(Single(Function(() throws -> DeclaredType(Single(Bool))))))))")192    XCTAssert(actual.isFunction)193  }194  195  func testDeclaredType_parsesParenthesizedFunction() {196    let actual = DeclaredType(from: "((Bool) -> Bool)")197    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Function((Parameter(DeclaredType(Single(Bool)))) -> DeclaredType(Single(Bool)))))")198    XCTAssert(actual.isFunction)199  }200  201  func testDeclaredType_parsesNestedParenthesizedFunction() {202    let actual = DeclaredType(from: "((((Bool) -> Bool)))")203    XCTAssertEqual(String(reflecting: actual), "DeclaredType(Single(Function((Parameter(DeclaredType(Single(Bool)))) -> DeclaredType(Single(Bool)))))")...

1let testDeclaredType_parsesChainedThrowingFunctionTypes = DeclaredTypeTests().testDeclaredType_parsesChainedThrowingFunctionTypes2let testDeclaredType_parsesFunctionTypes = DeclaredTypeTests().testDeclaredType_parsesFunctionTypes3let testDeclaredType_parsesImplicitlyUnwrappedFunctionTypes = DeclaredTypeTests().testDeclaredType_parsesImplicitlyUnwrappedFunctionTypes4let testDeclaredType_parsesImplicitlyUnwrappedOptionalFunctionTypes = DeclaredTypeTests().testDeclaredType_parsesImplicitlyUnwrappedOptionalFunctionTypes5let testDeclaredType_parsesImplicitlyUnwrappedOptionalTypes = DeclaredTypeTests().testDeclaredType_parsesImplicitlyUnwrappedOptionalTypes6let testDeclaredType_parsesImplicitlyUnwrappedTypes = DeclaredTypeTests().testDeclaredType_parsesImplicitlyUnwrappedTypes7let testDeclaredType_parsesOptionalFunctionTypes = DeclaredTypeTests().testDeclaredType_parsesOptionalFunctionTypes8let testDeclaredType_parsesOptionalTypes = DeclaredTypeTests().testDeclaredType_parsesOptionalTypes9let testDeclaredType_parsesThrows = DeclaredTypeTests().testDeclaredType_parsesThrows

11  import  XCTest22  import  SwiftSyntax33  import  SwiftSyntaxTest44  import  SwiftSyntaxBuilder56  final  class  DeclaredTypeTests: XCTestCase {68    func   testDeclaredType_parsesChainedThrowingFunctionTypes ( )   throws  {710      func foo() throws -> () throws -> () throws -> () {}812      let  syntax  =   try   SyntaxParser . parse ( source :  input ) 913      let  functionDecl  =  syntax . firstToken ( where :   {  $0 . is ( FunctionDeclSyntax . self )   } ) ! 1014      let  type  =  functionDecl . declaredType ( as :  FunctionTypeSyntax . self ) 1115      XCTAssertNotNil ( type ) 1216      let  type2  =  type ! . returnType ( as :  FunctionTypeSyntax . self ) 1317      XCTAssertNotNil ( type2 ) 1418      let  type3  =  type2 ! . returnType ( as :  FunctionTypeSyntax . self ) 1519      XCTAssertNotNil ( type3 ) 1620    }1721  }181  import  XCTest192  import  SwiftSyntax203  import  SwiftSyntaxTest214  import  SwiftSyntaxBuilder226  final  class  DeclaredTypeTests: XCTestCase {238    func   testDeclaredType_parsesChainedThrowingFunctionTypes ( )   throws  {2410      func foo() throws -> () throws -> () throws -> () {}2512      let  syntax  =   try   SyntaxParser . parse ( source :  input ) 2613      let  functionDecl  =  syntax . firstToken ( where :   {  $0 . is ( FunctionDeclSyntax . self )   } ) ! 2714      let  type  =  functionDecl . declaredType ( as :  FunctionTypeSyntax . self ) 2815      XCTAssertNotNil ( type ) 2916      let  type2  =  type ! . returnType ( as :  FunctionTypeSyntax . self ) 3017      XCTAssertNotNil (

1import SwiftSyntax2import XCTest3class DeclaredTypeTests : XCTestCase {4    func testDeclaredType_parsesChainedThrowingFunctionTypes() {5        func foo() throws -> (Int) throws -> String6        let syntax = try! SyntaxParser.parse(source: input)7        XCTAssertEqual(type?.description, "(Int) throws -> String")8    }9}10import SwiftSyntax11import XCTest12class DeclaredTypeTests : XCTestCase {13    func testDeclaredType_parsesChainedThrowingFunctionTypes() {14        func foo() throws -> (Int) throws -> String15        let syntax = try! SyntaxParser.parse(source: input)16        XCTAssertEqual(type?.description, "(Int) throws -> String")17    }18}19import SwiftSyntax20import XCTest21class DeclaredTypeTests : XCTestCase {22    func testDeclaredType_parsesChainedThrowingFunctionTypes() {23        func foo() throws -> (Int) throws -> String24        let syntax = try! SyntaxParser.parse(source: input)25        XCTAssertEqual(type?.description, "(Int) throws -> String")26    }27}28import SwiftSyntax29import XCTest30class DeclaredTypeTests : XCTestCase {31    func testDeclaredType_parsesChainedThrowingFunctionTypes() {32        func foo() throws -> (Int) throws -> String33        let syntax = try! SyntaxParser.parse(source: input)

1import Foundation2class DeclaredTypeTests {3    func testDeclaredType_parsesChainedThrowingFunctionTypes() {4        let type = try! declaredType(of: "Int throws -> String throws -> Bool")5        XCTAssertEqual(type, .function((.int, [.throws]), .function((.string, [.throws]), .bool)))6    }7}8import Foundation9class DeclaredTypeTests {10    func testDeclaredType_parsesChainedThrowingFunctionTypes() {11        let type = try! declaredType(of: "Int throws -> String throws -> Bool")12        XCTAssertEqual(type, .function((.int, [.throws]), .function((.string, [.throws]), .bool)))13    }14}15import Foundation16class DeclaredTypeTests {17    func testDeclaredType_parsesChainedThrowingFunctionTypes() {18        let type = try! declaredType(of: "Int throws -> String throws -> Bool")19        XCTAssertEqual(type, .function((.int, [.throws]), .function((.string, [.throws]), .bool)))20    }21}22import Foundation23class DeclaredTypeTests {24    func testDeclaredType_parsesChainedThrowingFunctionTypes() {25        let type = try! declaredType(of: "Int throws -> String throws -> Bool")26        XCTAssertEqual(type, .function((.int, [.throws]), .function((.string, [.throws]), .bool)))27    }28}29import Foundation30class DeclaredTypeTests {31    func testDeclaredType_parsesChainedThrowingFunctionTypes() {32        let type = try! declaredType(of: "Int throws -> String throws -> Bool")33        XCTAssertEqual(type, .function((.int, [.throws]), .function((.string, [.throws]), .bool)))34    }35}

1import Swift2class DeclaredTypeTests {3    func testDeclaredType_parsesChainedThrowingFunctionTypes() throws {4        let type = try DeclaredType("() throws -> () throws -> ()")5        XCTAssertEqual(type.description, "() throws -> () throws -> ()")6        XCTAssertEqual(type.isThrowing, true)7        XCTAssertEqual(type.isVoid, false)8        XCTAssertEqual(type.isOptional, false)9        XCTAssertEqual(type.isImplicitlyUnwrappedOptional, false)10        XCTAssertEqual(type.isAny, false)11        XCTAssertEqual(type.isAnyObject, false)12        XCTAssertEqual(type.isAnyHashable, false)13        XCTAssertEqual(type.isAnyClass, false)14        XCTAssertEqual(type.isAnyObject, false)15        XCTAssertEqual(type.isAnyHashable, false)16        XCTAssertEqual(type.isAnyCla