In AssertParse, allow asserting for a substructure that should occur in a syntax tree

ahoppen · ahoppen · commit b4f512492c21 · 2022-08-28T08:52:25.000+02:00
diff --git a/Sources/SwiftParser/SwiftParser.docc/FixingBugs.md b/Sources/SwiftParser/SwiftParser.docc/FixingBugs.md
@@ -27,20 +27,14 @@ Diagnostics are produced when the parsed syntax tree contains missing or unexpec
 
 1. Add a test case in `SwiftParserTest` that looks like the following
     ```swift
-    let source = """
-    <#your code that produces an invalid syntax tree#> 
-    """
-
-    let tree = withParser(source: source) {
-      Syntax(raw: $0.parseSourceFile().raw)
-    }
-    XCTAssertHasSubstructure(
-      tree,
-      <#create a syntax node that you expect the tree to have#>
+    AssertParse(
+      """
+      <#your code that produces an invalid syntax tree#> 
+      """,
+      substructure: <#create a syntax node that you expect the tree to have#>
     )
     ```
-2. Optional: Reduce the test case even further by deleting more source code and calling into a specific production of the parser instead of `Parser.parseSourceFile`
-3. Run the test case and navigate the debugger to the place that produced the invalid syntax node. 
+2. Run the test case and navigate the debugger to the place that produced the invalid syntax node. 
 
 ## Unhelpful Diagnostic Produced
 
diff --git a/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift b/Sources/_SwiftSyntaxTestSupport/Syntax+Assertions.swift
@@ -33,60 +33,6 @@ public func XCTAssertNextIsNil<Iterator: IteratorProtocol>(_ iterator: inout Ite
   XCTAssertNil(iterator.next())
 }
 
-/// Verifies that the tree parsed from `actual` has the same structure as
-/// `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<ActualTree, ExpectedTree>(
-  _ actual: ActualTree,
-  _ expected: ExpectedTree,
-  includeTrivia: Bool = false,
-  file: StaticString = #filePath, line: UInt = #line
-)
-  where ActualTree: SyntaxProtocol, ExpectedTree: SyntaxProtocol
-{
-  let diff = actual.findFirstDifference(baseline: expected, includeTrivia: includeTrivia)
-  XCTAssertNil(diff, diff!.debugDescription, file: file, line: line)
-}
-
-/// See `SubtreeMatcher.assertSameStructure`.
-public func XCTAssertHasSubstructure<ExpectedTree: SyntaxProtocol>(
-  _ markedText: String,
-  parse: (String) throws -> Syntax,
-  afterMarker: String? = nil,
-  _ expected: ExpectedTree,
-  includeTrivia: Bool = false,
-  file: StaticString = #filePath, line: UInt = #line
-) throws {
-  let subtreeMatcher = try SubtreeMatcher(markedText, parse: parse)
-  try subtreeMatcher.assertSameStructure(afterMarker: afterMarker, Syntax(expected), file: file, line: line)
-}
-
-/// See `SubtreeMatcher.assertSameStructure`.
-public func XCTAssertHasSubstructure<ActualTree, ExpectedTree>(
-  _ actualTree: ActualTree,
-  _ expected: ExpectedTree,
-  includeTrivia: Bool = false,
-  file: StaticString = #filePath, line: UInt = #line
-) throws
-  where ActualTree: SyntaxProtocol, ExpectedTree: SyntaxProtocol
-{
-  let subtreeMatcher = SubtreeMatcher(Syntax(actualTree))
-  try subtreeMatcher.assertSameStructure(Syntax(expected), file: file, line: line)
-}
-
 /// Allows matching a subtrees of the given `markedText` against
 /// `baseline`/`expected` trees, where a combination of markers and the type
 /// of the `expected` tree is used to first find the subtree to match. Note
@@ -141,8 +87,8 @@ public struct SubtreeMatcher {
     self.actualTree = try parse(text)
   }
 
-  public init(_ actualTree: Syntax) {
-    self.markers = ["DEFAULT": 0]
+  public init(_ actualTree: Syntax, markers: [String: Int]) {
+    self.markers = markers.isEmpty ? ["DEFAULT": 0] : markers
     self.actualTree = actualTree
   }
 
@@ -162,8 +108,8 @@ public struct SubtreeMatcher {
     return subtree.findFirstDifference(baseline: baseline, includeTrivia: includeTrivia)
   }
 
-  /// Same as `XCTAssertSameStructure`, but uses the subtree found from parsing
-  /// the text passed into `init(markedText:)` as the `actual` tree.
+  /// Verifies that the the subtree found from parsing the text passed into
+  /// `init(markedText:)` has the same structure as `expected`.
   public func assertSameStructure(afterMarker: String? = nil, _ expected: Syntax, includeTrivia: Bool = false,
                                   file: StaticString = #filePath, line: UInt = #line) throws {
     let diff = try findFirstDifference(afterMarker: afterMarker, baseline: expected, includeTrivia: includeTrivia)
diff --git a/Tests/SwiftParserTest/Assertions.swift b/Tests/SwiftParserTest/Assertions.swift
@@ -160,9 +160,11 @@ func AssertDiagnostic<T: SyntaxProtocol>(
 /// These markers are removed before parsing the source file.
 /// By default, `DiagnosticSpec` asserts that the diagnostics is produced at a location marked by `#^DIAG^#`.
 /// `parseSyntax` can be used to adjust the production that should be used as the entry point to parse the source code.
+/// If `substructure` is not `nil`, asserts that the parsed syntax tree contains this substructure.
 func AssertParse<Node: RawSyntaxNodeProtocol>(
   _ markedSource: String,
   _ parseSyntax: (inout Parser) -> Node = { $0.parseSourceFile() },
+  substructure expectedSubstructure: Syntax? = nil,
   diagnostics expectedDiagnostics: [DiagnosticSpec] = [],
   fixedSource expectedFixedSource: String? = nil,
   file: StaticString = #file,
@@ -175,12 +177,26 @@ func AssertParse<Node: RawSyntaxNodeProtocol>(
     var parser = Parser(buf)
     withExtendedLifetime(parser) {
       let tree = Syntax(raw: parseSyntax(&parser).raw)
+
+      // Round-trip
       AssertStringsEqualWithDiff("\(tree)", source, additionalInfo: """
       Source failed to round-trip.
 
       Actual syntax tree:
       \(tree.recursiveDescription)
       """, file: file, line: line)
+
+      // Substructure
+      if let expectedSubstructure = expectedSubstructure {
+        let subtreeMatcher = SubtreeMatcher(Syntax(tree), markers: [:])
+        do {
+          try subtreeMatcher.assertSameStructure(Syntax(expectedSubstructure), file: file, line: line)
+        } catch {
+          XCTFail("Matching for a subtree failed with error: \(error)", file: file, line: line)
+        }
+      }
+
+      // Diagnostics
       let diags = ParseDiagnosticsGenerator.diagnostics(for: tree)
       XCTAssertEqual(diags.count, expectedDiagnostics.count, """
       Expected \(expectedDiagnostics.count) diagnostics but received \(diags.count):
@@ -189,6 +205,8 @@ func AssertParse<Node: RawSyntaxNodeProtocol>(
       for (diag, expectedDiag) in zip(diags, expectedDiagnostics) {
         AssertDiagnostic(diag, in: tree, markerLocations: markerLocations, expected: expectedDiag, file: file, line: line)
       }
+
+      // Applying Fix-Its
       if let expectedFixedSource = expectedFixedSource {
         let fixedSource = FixItApplier.applyFixes(in: diags, to: tree).description
         AssertStringsEqualWithDiff(fixedSource, expectedFixedSource, file: file, line: line)
diff --git a/Tests/SwiftParserTest/RecoveryTests.swift b/Tests/SwiftParserTest/RecoveryTests.swift
@@ -4,11 +4,11 @@ import XCTest
 import _SwiftSyntaxTestSupport
 
 public class RecoveryTests: XCTestCase {
-  func testRecoverOneExtraLabel() throws {
-    try XCTAssertHasSubstructure(
-      "(first second third: Int)",
-      parse: { withParser(source: $0) { Syntax(raw: $0.parseFunctionSignature().raw) } },
-      FunctionParameterSyntax(
+  func testRecoverOneExtraLabel() {
+    AssertParse(
+      "(first second #^DIAG^#third: Int)",
+      { $0.parseFunctionSignature() },
+      substructure: Syntax(FunctionParameterSyntax(
         attributes: nil,
         firstName: TokenSyntax.identifier("first"),
         secondName: TokenSyntax.identifier("second"),
@@ -18,15 +18,18 @@ public class RecoveryTests: XCTestCase {
         ellipsis: nil,
         defaultArgument: nil,
         trailingComma: nil
-      )
+      )),
+      diagnostics: [
+        DiagnosticSpec(message: "Unexpected text 'third' found in function parameter")
+      ]
     )
   }
 
-  func testRecoverTwoExtraLabels() throws {
-    try XCTAssertHasSubstructure(
-      "(first second third fourth: Int)",
-      parse: { withParser(source: $0) { Syntax(raw: $0.parseFunctionSignature().raw) } },
-      FunctionParameterSyntax(
+  func testRecoverTwoExtraLabels() {
+    AssertParse(
+      "(first second #^DIAG^#third fourth: Int)",
+      { $0.parseFunctionSignature() },
+      substructure: Syntax(FunctionParameterSyntax(
         attributes: nil,
         firstName: TokenSyntax.identifier("first"),
         secondName: TokenSyntax.identifier("second"),
@@ -36,30 +39,42 @@ public class RecoveryTests: XCTestCase {
         ellipsis: nil,
         defaultArgument: nil,
         trailingComma: nil
-      )
+      )),
+      diagnostics: [
+        DiagnosticSpec(message: "Unexpected text 'third fourth' found in function parameter")
+      ]
     )
   }
 
   func testDontRecoverFromDeclKeyword() {
-    var source = """
-    (first second third struct: Int)
-    """
-    let (_, currentToken): (RawFunctionSignatureSyntax, Lexer.Lexeme) =
-      source.withUTF8 { buffer in
-        var parser = Parser(buffer)
-        return (parser.parseFunctionSignature(), parser.currentToken)
-      }
-
-    // The 'struct' keyword should be taken as an indicator that a new decl
-    // starts here, so `parseFunctionSignature` shouldn't eat it.
-    XCTAssertEqual(currentToken.tokenKind, .structKeyword)
+    AssertParse(
+      "func foo(first second #^MISSING_COLON^#third #^MISSING_RPAREN^#struct#^MISSING_IDENTIFIER^##^BRACES^#: Int) {}",
+      substructure: Syntax(FunctionParameterSyntax(
+        attributes: nil,
+        firstName: .identifier("first"),
+        secondName: .identifier("second"),
+        colon: .colonToken(presence: .missing),
+        type: TypeSyntax(SimpleTypeIdentifierSyntax(name: .identifier("third"), genericArgumentClause: nil)),
+        ellipsis: nil,
+        defaultArgument: nil,
+        trailingComma: nil
+      )),
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "MISSING_COLON", message: "Expected ':' in function parameter"),
+        DiagnosticSpec(locationMarker: "MISSING_RPAREN", message: "Expected ')' to end parameter clause"),
+        // FIXME: We should issues something like "Expected identifier in declaration"
+        DiagnosticSpec(locationMarker: "MISSING_IDENTIFIER", message: "Expected '' in declaration"),
+        DiagnosticSpec(locationMarker: "BRACES", message: "Expected '{'"),
+        DiagnosticSpec(locationMarker: "BRACES", message: "Expected '}'"),
+      ]
+    )
   }
 
-  func testRecoverFromParens() throws {
-    try XCTAssertHasSubstructure(
-      "(first second [third fourth]: Int)",
-      parse: { withParser(source: $0) { Syntax(raw: $0.parseFunctionSignature().raw) } },
-      FunctionParameterSyntax(
+  func testRecoverFromParens() {
+    AssertParse(
+      "(first second #^DIAG^#[third fourth]: Int)",
+      { $0.parseFunctionSignature() },
+      substructure: Syntax(FunctionParameterSyntax(
         attributes: nil,
         firstName: TokenSyntax.identifier("first"),
         secondName: TokenSyntax.identifier("second"),
@@ -74,68 +89,71 @@ public class RecoveryTests: XCTestCase {
         ellipsis: nil,
         defaultArgument: nil,
         trailingComma: nil
-      )
+      )),
+      diagnostics: [
+        DiagnosticSpec(message: "Unexpected text '[third fourth]' found in function parameter")
+      ]
     )
   }
 
-  func testDontRecoverFromUnbalancedParens() throws {
-    let source = """
-    (first second [third fourth: Int)
-    """
-    try withParser(source: source) { parser in
-      let signature = Syntax(raw: parser.parseFunctionSignature().raw)
-      let currentToken = parser.currentToken
-      XCTAssertEqual(currentToken.tokenKind, .identifier)
-      XCTAssertEqual(currentToken.tokenText, "fourth")
-      try XCTAssertHasSubstructure(
-        signature,
-        FunctionParameterSyntax(
-          attributes: nil,
-          firstName: TokenSyntax.identifier("first"),
-          secondName: TokenSyntax.identifier("second"),
-          colon: TokenSyntax(.colon, presence: .missing),
-          type: TypeSyntax(ArrayTypeSyntax(
-            leftSquareBracket: TokenSyntax.leftSquareBracketToken(),
-            elementType: TypeSyntax(SimpleTypeIdentifierSyntax(name: TokenSyntax.identifier("third"), genericArgumentClause: nil)),
-            rightSquareBracket: TokenSyntax(.rightSquareBracket, presence: .missing)
-          )),
-          ellipsis: nil,
-          defaultArgument: nil,
-          trailingComma: nil
-        )
-      )
-    }
+  func testDontRecoverFromUnbalancedParens() {
+    AssertParse(
+      "func foo(first second #^COLON^#[third #^RSQUARE_COLON^#fourth: Int) {}",
+      substructure: Syntax(FunctionParameterSyntax(
+        attributes: nil,
+        firstName: TokenSyntax.identifier("first"),
+        secondName: TokenSyntax.identifier("second"),
+        colon: TokenSyntax(.colon, presence: .missing),
+        type: TypeSyntax(ArrayTypeSyntax(
+          leftSquareBracket: TokenSyntax.leftSquareBracketToken(),
+          elementType: TypeSyntax(SimpleTypeIdentifierSyntax(name: TokenSyntax.identifier("third"), genericArgumentClause: nil)),
+          rightSquareBracket: TokenSyntax(.rightSquareBracket, presence: .missing)
+        )),
+        ellipsis: nil,
+        defaultArgument: nil,
+        trailingComma: nil
+      )),
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "COLON", message: "Expected ':' in function parameter"),
+        DiagnosticSpec(locationMarker: "RSQUARE_COLON" , message: "Expected ']' to end type"),
+        DiagnosticSpec(locationMarker: "RSQUARE_COLON", message: "Expected ')' to end parameter clause"),
+      ]
+    )
   }
 
   func testDontRecoverIfNewlineIsBeforeColon() {
-    var source = """
-    (first second third
-    : Int)
-    """
-    let (_, currentToken): (RawFunctionSignatureSyntax, Lexer.Lexeme) =
-      source.withUTF8 { buffer in
-        var parser = Parser(buffer)
-        return (parser.parseFunctionSignature(), parser.currentToken)
-      }
-
-    XCTAssertEqual(currentToken.tokenKind, .colon)
+    AssertParse(
+      """
+      func foo(first second #^COLON^#third#^RPAREN^#
+      : Int) {}
+      """,
+      substructure: Syntax(FunctionParameterSyntax(
+        attributes: nil,
+        firstName: TokenSyntax.identifier("first"),
+        secondName: TokenSyntax.identifier("second"),
+        colon: TokenSyntax(.colon, presence: .missing),
+        type: TypeSyntax(SimpleTypeIdentifierSyntax(name: TokenSyntax.identifier("third"), genericArgumentClause: nil)),
+        ellipsis: nil,
+        defaultArgument: nil,
+        trailingComma: nil
+      )),
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "COLON", message: "Expected ':' in function parameter"),
+        DiagnosticSpec(locationMarker: "RPAREN", message: "Expected ')' to end parameter clause"),
+      ]
+    )
   }
 
-  public func testNoParamsForFunction() throws {
-    let source = """
-    class MyClass {
-      func withoutParameters
-
-      func withParameters() {}
-    }
-    """
+  public func testNoParamsForFunction() {
+    AssertParse(
+      """
+      class MyClass {
+        func withoutParameters#^DIAG^#
 
-    let classDecl = withParser(source: source) {
-      Syntax(raw: $0.parseDeclaration().raw)
-    }
-    try XCTAssertHasSubstructure(
-      classDecl,
-      FunctionDeclSyntax(
+        func withParameters() {}
+      }
+      """,
+      substructure: Syntax(FunctionDeclSyntax(
         attributes: nil,
         modifiers: nil,
         funcKeyword: .funcKeyword(),
@@ -153,7 +171,10 @@ public class RecoveryTests: XCTestCase {
         ),
         genericWhereClause: nil,
         body: nil
-      )
+      )),
+      diagnostics: [
+        DiagnosticSpec(message: "Expected argument list in function declaration")
+      ]
     )
   }
 }
