Add a SwiftSyntaxTestSupport target

Package.swift

@@ -90,6 +90,10 @@ let package = Package(
       ],
       linkerSettings: swiftSyntaxParserLinkerSettings
     ),
+    .target(
+      name: "_SwiftSyntaxTestSupport",
+      dependencies: ["SwiftSyntax"]
+    ),
     .target(
       name: "lit-test-helper",
       dependencies: ["SwiftSyntax", "SwiftSyntaxParser"]
@@ -121,15 +125,15 @@ let package = Package(
     ),
     .testTarget(
       name: "SwiftSyntaxTest",
-      dependencies: ["SwiftSyntax"]
+      dependencies: ["SwiftSyntax", "_SwiftSyntaxTestSupport"]
     ),
     .testTarget(
       name: "SwiftSyntaxBuilderTest",
       dependencies: ["SwiftSyntaxBuilder"]
     ),
     .testTarget(
       name: "SwiftSyntaxParserTest",
-      dependencies: ["SwiftSyntaxParser"],
+      dependencies: ["SwiftSyntaxParser", "_SwiftSyntaxTestSupport"],
       exclude: ["Inputs"]
     ),
     .testTarget(

Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift

@@ -0,0 +1,34 @@
+//===------------------- Syntax+Assertions.swift  -------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Syntax assertion helpers.
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+import XCTest
+
+/// Verifies that there is a next item returned by the iterator and that it
+/// satisfies the given predicate.
+public func XCTAssertNext<Iterator: IteratorProtocol>(
+  _ iterator: inout Iterator,
+  satisfies predicate: (Iterator.Element) throws -> Bool,
+  file: StaticString = #filePath, line: UInt = #line
+) throws {
+  let next = try XCTUnwrap(iterator.next(), file: file, line: line)
+  XCTAssertTrue(try predicate(next), file: file, line: line)
+}
+
+/// Verifies that the iterator is exhausted.
+public func XCTAssertNextIsNil<Iterator: IteratorProtocol>(_ iterator: inout Iterator) {
+  XCTAssertNil(iterator.next())
+}

Sources/_SwiftSyntaxTestSupport/SyntaxCollection+AtIndex.swift.swift

@@ -0,0 +1,33 @@
+//===----------------- SyntaxCollection+AtIndex.swift  --------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// O(n) test method for grabbing a child at a particular index.
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+public extension SyntaxCollection {
+  /// Gets the child at the provided index in this node's present children.
+  /// This is not provided by the Syntax API because its performance is O(n).
+  /// We add it here in `SyntaxCollection` for testing purposes.
+  func child(at index: Int) -> Element? {
+    guard index >= 0 && index < self.count else { return nil }
+    var iter = self.makeIterator()
+    for _ in 0..<index { _ = iter.next() }
+    return iter.next()!
+  }
+
+  subscript(_ index: Int) -> Element {
+    return child(at: index)!
+  }
+}

Sources/_SwiftSyntaxTestSupport/TestUtils.swift

@@ -0,0 +1,25 @@
+//===--------- TestUtils.swift - Syntax Parsing ---------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Various utilities to aid in syntax tree testing.
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+
+public func getTestInput(_ file: String, baseFile: String = #file) -> URL {
+  var result = URL(fileURLWithPath: baseFile)
+  result.deleteLastPathComponent()
+  result.appendPathComponent("Inputs")
+  result.appendPathComponent(file)
+  return result
+}

Tests/SwiftSyntaxParserTest/AbsolutePositionTests.swift

@@ -1,6 +1,7 @@
 import XCTest
 import SwiftSyntax
 import SwiftSyntaxParser
+import _SwiftSyntaxTestSupport
 
 fileprivate class FuncRenamer: SyntaxRewriter {
   override func visit(_ node: FunctionDeclSyntax) -> DeclSyntax {
@@ -15,8 +16,8 @@ public class AbsolutePositionTests: XCTestCase {
 
   public func testVisitor() {
     XCTAssertNoThrow(try {
-      let source = try String(contentsOf: getInput("visitor.swift"))
-      let parsed = try SyntaxParser.parse(getInput("visitor.swift"))
+      let source = try String(contentsOf: getTestInput("visitor.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("visitor.swift"))
       XCTAssertEqual(0, parsed.position.utf8Offset)
       XCTAssertEqual(source.count,
         parsed.eofToken.positionAfterSkippingLeadingTrivia.utf8Offset)
@@ -27,8 +28,8 @@ public class AbsolutePositionTests: XCTestCase {
 
   public func testClosure() {
     XCTAssertNoThrow(try {
-      let source = try String(contentsOf: getInput("closure.swift"))
-      let parsed = try SyntaxParser.parse(getInput("closure.swift"))
+      let source = try String(contentsOf: getTestInput("closure.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("closure.swift"))
       XCTAssertEqual(source.count, 
         parsed.eofToken.positionAfterSkippingLeadingTrivia.utf8Offset)
       XCTAssertEqual(0, parsed.position.utf8Offset)
@@ -38,7 +39,7 @@ public class AbsolutePositionTests: XCTestCase {
 
   public func testRename() {
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("visitor.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("visitor.swift"))
       let renamed = FuncRenamer().visit(parsed).as(SourceFileSyntax.self)!
       let renamedSource = renamed.description
       XCTAssertEqual(renamedSource.count, 

Tests/SwiftSyntaxParserTest/SyntaxVisitorTests.swift

@@ -1,6 +1,7 @@
 import XCTest
 import SwiftSyntax
 import SwiftSyntaxParser
+import _SwiftSyntaxTestSupport
 
 public class SyntaxVisitorTests: XCTestCase {
 
@@ -13,7 +14,7 @@ public class SyntaxVisitorTests: XCTestCase {
       }
     }
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("visitor.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("visitor.swift"))
       let counter = FuncCounter()
       let hashBefore = parsed.hashValue
       counter.walk(parsed)
@@ -30,7 +31,7 @@ public class SyntaxVisitorTests: XCTestCase {
       }
     }
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("closure.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("closure.swift"))
       let rewriter = ClosureRewriter()
       let rewritten = rewriter.visit(parsed)
       XCTAssertEqual(parsed.description, rewritten.description)
@@ -51,7 +52,7 @@ public class SyntaxVisitorTests: XCTestCase {
       }
     }
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("near-empty.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("near-empty.swift"))
       let rewriter = VisitAnyRewriter(transform: { _ in
          return SyntaxFactory.makeIdentifier("")
       })
@@ -71,7 +72,7 @@ public class SyntaxVisitorTests: XCTestCase {
     }
 
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("nested-blocks.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("nested-blocks.swift"))
       let visitor = VisitCollections()
       visitor.walk(parsed)
       XCTAssertEqual(4, visitor.numberOfCodeBlockItems)
@@ -87,7 +88,7 @@ public class SyntaxVisitorTests: XCTestCase {
       }
     }
     XCTAssertNoThrow(try {
-      let parsed = try SyntaxParser.parse(getInput("visitor.swift"))
+      let parsed = try SyntaxParser.parse(getTestInput("visitor.swift"))
       let counter = FuncCounter()
       let hashBefore = parsed.hashValue
       counter.walk(parsed)

Tests/SwiftSyntaxTest/SyntaxChildrenTests.swift

@@ -1,26 +1,27 @@
 import XCTest
 import SwiftSyntax
+import _SwiftSyntaxTestSupport
 
 public class SyntaxChildrenTests: XCTestCase {
 
-  public func testIterateWithAllPresent() {
+  public func testIterateWithAllPresent() throws {
     let returnStmt = SyntaxFactory.makeReturnStmt(
       returnKeyword: SyntaxFactory.makeReturnKeyword(),
       expression: ExprSyntax(SyntaxFactory.makeBlankUnknownExpr()))
 
     var iterator = returnStmt.children.makeIterator()
-    XCTAssertNext(&iterator) { $0.as(TokenSyntax.self)?.tokenKind == .returnKeyword }
-    XCTAssertNext(&iterator) { $0.is(ExprSyntax.self) }
+    try XCTAssertNext(&iterator) { $0.as(TokenSyntax.self)?.tokenKind == .returnKeyword }
+    try XCTAssertNext(&iterator) { $0.is(ExprSyntax.self) }
     XCTAssertNextIsNil(&iterator)
   }
 
-  public func testIterateWithSomeMissing() {
+  public func testIterateWithSomeMissing() throws {
     let returnStmt = SyntaxFactory.makeReturnStmt(
       returnKeyword: SyntaxFactory.makeReturnKeyword(),
       expression: nil)
 
     var iterator = returnStmt.children.makeIterator()
-    XCTAssertNext(&iterator) { $0.as(TokenSyntax.self)?.tokenKind == .returnKeyword }
+    try XCTAssertNext(&iterator) { $0.as(TokenSyntax.self)?.tokenKind == .returnKeyword }
     XCTAssertNextIsNil(&iterator)
   }
 

Tests/SwiftSyntaxTest/SyntaxCollectionsTests.swift

@@ -1,5 +1,6 @@
 import XCTest
 import SwiftSyntax
+import _SwiftSyntaxTestSupport
 
 fileprivate func integerLiteralElement(_ int: Int) -> ArrayElementSyntax {
     let literal = SyntaxFactory.makeIntegerLiteral("\(int)")