Remove dependency from _SwiftSyntaxTestSupport on SyntaxParser.parse

This allows us to invoke the parser more flexibly to, e.g. only parse subtrees.

Author: ahoppen

Package.swift

@@ -91,7 +91,7 @@ let package = Package(
     ),
     .target(
       name: "_SwiftSyntaxTestSupport",
-      dependencies: ["SwiftSyntax", "SwiftSyntaxParser"]
+      dependencies: ["SwiftSyntax"]
     ),
     .executableTarget(
       name: "lit-test-helper",

Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift

@@ -15,7 +15,6 @@
 //===----------------------------------------------------------------------===//
 
 import SwiftSyntax
-import SwiftSyntaxParser
 import XCTest
 
 /// Verifies that there is a next item returned by the iterator and that it
@@ -35,18 +34,27 @@ public func XCTAssertNextIsNil<Iterator: IteratorProtocol>(_ iterator: inout Ite
 }
 
 /// Verifies that the tree parsed from `actual` has the same structure as
-/// `expected`, ie. it has the same structure and optionally the same trivia
-/// (if `includeTrivia` is set).
-public func XCTAssertSameStructure(_ actual: String, _ expected: Syntax, includeTrivia: Bool = false,
-                                   file: StaticString = #filePath, line: UInt = #line) throws {
-  let actualTree = try Syntax(SyntaxParser.parse(source: actual))
+/// `expected` when parsed with `parse`, ie. it has the same structure and
+/// optionally the same trivia (if `includeTrivia` is set).
+public func XCTAssertSameStructure(
+  _ actual: String,
+  parse: (String) throws -> Syntax,
+  _ expected: Syntax,
+  includeTrivia: Bool = false,
+  file: StaticString = #filePath, line: UInt = #line
+) throws {
+  let actualTree = try parse(actual)
   XCTAssertSameStructure(actualTree, expected, includeTrivia: includeTrivia, file: file, line: line)
 }
 
 /// Verifies that two trees are equivalent, ie. they have the same structure
 /// and optionally the same trivia if `includeTrivia` is set.
-public func XCTAssertSameStructure(_ actual: Syntax, _ expected: Syntax, includeTrivia: Bool = false,
-                                   file: StaticString = #filePath, line: UInt = #line) {
+public func XCTAssertSameStructure(
+  _ actual: SyntaxProtocol,
+  _ expected: SyntaxProtocol,
+  includeTrivia: Bool = false,
+  file: StaticString = #filePath, line: UInt = #line
+) {
   let diff = actual.findFirstDifference(baseline: expected, includeTrivia: includeTrivia)
   XCTAssertNil(diff, diff!.debugDescription, file: file, line: line)
 }
@@ -98,7 +106,7 @@ public struct SubtreeMatcher {
   /// The syntax tree from parsing source *with markers removed*.
   private var actualTree: Syntax
 
-  public init(_ markedText: String) throws {
+  public init(_ markedText: String, parse: (String) throws -> Syntax) throws {
     var text = ""
     var markers = [String: Int]()
     var lastIndex = markedText.startIndex
@@ -112,7 +120,7 @@ public struct SubtreeMatcher {
     text += markedText[lastIndex ..< markedText.endIndex]
 
     self.markers = markers.isEmpty ? ["DEFAULT": 0] : markers
-    self.actualTree = try Syntax(SyntaxParser.parse(source: text))
+    self.actualTree = try parse(text)
   }
 
   /// Same as `Syntax.findFirstDifference(baseline:includeTrivia:)`, but

Tests/SwiftSyntaxTest/SyntaxComparisonTests.swift renamed to Tests/SwiftSyntaxParserTest/SyntaxComparisonTests.swift

@@ -1,15 +1,20 @@
 import SwiftSyntax
 import _SwiftSyntaxTestSupport
+import SwiftSyntaxParser
 import XCTest
 
+private func parse(source: String) throws -> Syntax {
+  return try Syntax(SyntaxParser.parse(source: source))
+}
+
 public class SyntaxComparisonTests: XCTestCase {
   public func testSame() throws {
     let expected = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("f")))
 
     let actual = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("f")))
     XCTAssertNil(actual.findFirstDifference(baseline: expected))
 
-    let matcher = try SubtreeMatcher("struct A { func f() { } }")
+    let matcher = try SubtreeMatcher("struct A { func f() { } }", parse: parse)
     try XCTAssertNil(matcher.findFirstDifference(baseline: expected))
   }
 
@@ -36,7 +41,7 @@ public class SyntaxComparisonTests: XCTestCase {
     let actual = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("f")))
     try expectations(actual.findFirstDifference(baseline: expected))
 
-    let matcher = try SubtreeMatcher("struct A { #^FUNC^#func f() { } }")
+    let matcher = try SubtreeMatcher("struct A { #^FUNC^#func f() { } }", parse: parse)
     try expectations(matcher.findFirstDifference(baseline: expected))
   }
 
@@ -52,7 +57,7 @@ public class SyntaxComparisonTests: XCTestCase {
     let actual = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("g")))
     try expectations(actual.findFirstDifference(baseline: expected))
 
-    let matcher = try SubtreeMatcher("struct A { #^FUNC^#func g() { } }")
+    let matcher = try SubtreeMatcher("struct A { #^FUNC^#func g() { } }", parse: parse)
     try expectations(matcher.findFirstDifference(afterMarker: "FUNC", baseline: expected))
   }
 
@@ -69,7 +74,7 @@ public class SyntaxComparisonTests: XCTestCase {
     XCTAssertNil(actual.findFirstDifference(baseline: expected))
     try expectations(actual.findFirstDifference(baseline: expected, includeTrivia: true))
 
-    let matcher = try SubtreeMatcher("struct A {func f() { }}")
+    let matcher = try SubtreeMatcher("struct A {func f() { }}", parse: parse)
     try XCTAssertNil(matcher.findFirstDifference(baseline: expected))
     try expectations(matcher.findFirstDifference(baseline: expected, includeTrivia: true))
   }
@@ -86,7 +91,7 @@ public class SyntaxComparisonTests: XCTestCase {
     let actual = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("f")))
     try expectations(actual.findFirstDifference(baseline: expected))
 
-    let matcher = try SubtreeMatcher("struct A { func f() { } }")
+    let matcher = try SubtreeMatcher("struct A { func f() { } }", parse: parse)
     try expectations(matcher.findFirstDifference(baseline: expected))
   }
 
@@ -100,7 +105,7 @@ public class SyntaxComparisonTests: XCTestCase {
     let actual = Syntax(makeFunc(identifier: SyntaxFactory.makeIdentifier("f")))
     try expectations(actual.findFirstDifference(baseline: expected))
 
-    let matcher = try SubtreeMatcher("struct A { func f() { } }")
+    let matcher = try SubtreeMatcher("struct A { func f() { } }", parse: parse)
     try expectations(matcher.findFirstDifference(baseline: expected))
   }
 
@@ -120,7 +125,7 @@ public class SyntaxComparisonTests: XCTestCase {
           0
         }
       }
-      """)
+      """, parse: parse)
     try expectations(matcher.findFirstDifference(baseline: expected))
   }
 
@@ -137,7 +142,7 @@ public class SyntaxComparisonTests: XCTestCase {
           0
         }
       }
-      """)
+      """, parse: parse)
     let funcDiff = try XCTUnwrap(matcher.findFirstDifference(afterMarker: "FUNC", baseline: expectedFunc))
     XCTAssertEqual(funcDiff.reason, .additionalNode)