Reduce places in which we pass a custom parse function to assertParse

In many of these places, the test case tested the exact same thing if we didn’t pass a custom `parse` function to `assertParsse`. Default to `SourceFileSyntax.parse` because it produces the more natural diagnostics.

Author: ahoppen

Tests/SwiftParserTest/Assertions.swift

@@ -529,35 +529,6 @@ public struct AssertParseOptions: OptionSet {
 }
 
 extension ParserTestCase {
-  /// Same as `assertParse` overload with a `(String) -> S` `parse`,
-  /// parsing the resulting `String` as a ``SourceFileSyntax``.
-  func assertParse(
-    _ markedSource: String,
-    substructure expectedSubstructure: (some SyntaxProtocol)? = Optional<Syntax>.none,
-    substructureAfterMarker: String = "START",
-    diagnostics expectedDiagnostics: [DiagnosticSpec] = [],
-    applyFixIts: [String]? = nil,
-    fixedSource expectedFixedSource: String? = nil,
-    options: AssertParseOptions = [],
-    experimentalFeatures: Parser.ExperimentalFeatures? = nil,
-    file: StaticString = #file,
-    line: UInt = #line
-  ) {
-    assertParse(
-      markedSource,
-      { SourceFileSyntax.parse(from: &$0) },
-      substructure: expectedSubstructure,
-      substructureAfterMarker: substructureAfterMarker,
-      diagnostics: expectedDiagnostics,
-      applyFixIts: applyFixIts,
-      fixedSource: expectedFixedSource,
-      options: options,
-      experimentalFeatures: experimentalFeatures,
-      file: file,
-      line: line
-    )
-  }
-
   /// After a test case has been mutated, assert that the mutated source
   /// round-trips and doesn’t hit any assertion failures in the parser.
   fileprivate func assertRoundTrip<S: SyntaxProtocol>(
@@ -615,7 +586,7 @@ extension ParserTestCase {
   ///     `nil` to enable the default set of features provided by the test case.
   func assertParse<S: SyntaxProtocol>(
     _ markedSource: String,
-    _ parse: (inout Parser) -> S,
+    _ parse: (inout Parser) -> S = { SourceFileSyntax.parse(from: &$0) },
     substructure expectedSubstructure: (some SyntaxProtocol)? = Optional<Syntax>.none,
     substructureAfterMarker: String = "START",
     diagnostics expectedDiagnostics: [DiagnosticSpec] = [],

Tests/SwiftParserTest/DeclarationTests.swift

@@ -118,10 +118,7 @@ final class DeclarationTests: ParserTestCase {
       """
     )
 
-    assertParse(
-      "<@NSApplicationMain T: AnyObject>",
-      { GenericParameterClauseSyntax.parse(from: &$0) }
-    )
+    assertParse("struct A<@NSApplicationMain T: AnyObject> {}")
 
     assertParse(
       "class T where t1️⃣",

Tests/SwiftParserTest/ExpressionTests.swift

@@ -1022,7 +1022,6 @@ final class ExpressionTests: ParserTestCase {
   func testParseArrowExpr() {
     assertParse(
       "Foo 1️⃣async ->2️⃣",
-      { ExprSyntax.parse(from: &$0) },
       substructure: TokenSyntax.keyword(.async),
       substructureAfterMarker: "1️⃣",
       diagnostics: [

Tests/SwiftParserTest/StatementTests.swift

@@ -138,11 +138,10 @@ final class StatementTests: ParserTestCase {
   }
 
   func testReturn() {
-    assertParse("return actor", { StmtSyntax.parse(from: &$0) })
+    assertParse("return actor")
 
     assertParse(
       "{ 1️⃣return 0 }",
-      { ExprSyntax.parse(from: &$0) },
       substructure: ReturnStmtSyntax(
         returnKeyword: .keyword(.return),
         expression: IntegerLiteralExprSyntax(literal: .integerLiteral("0"))

Tests/SwiftParserTest/TypeTests.swift

@@ -30,28 +30,22 @@ final class TypeTests: ParserTestCase {
   }
 
   func testClosureParsing() {
-    assertParse(
-      "(a, b) -> c",
-      { TypeSyntax.parse(from: &$0) }
-    )
+    assertParse("let a: (a, b) -> c")
 
-    assertParse(
-      "@MainActor (a, b) async throws -> c",
-      { TypeSyntax.parse(from: &$0) }
-    )
+    assertParse("let a: @MainActor (a, b) async throws -> c")
 
     assertParse("() -> (\u{feff})")
   }
 
   func testGenericTypeWithTrivia() {
-    // N.B. Whitespace is significant here.
+    // Whitespace is significant here.
     assertParse(
       """
+      let a:
               Foo<Bar<
                   V, Baz<Quux>
               >>
-      """,
-      { TypeSyntax.parse(from: &$0) }
+      """
     )
   }
 
@@ -82,20 +76,17 @@ final class TypeTests: ParserTestCase {
       """
       { ()
       throws -> Void in }
-      """,
-      { ExprSyntax.parse(from: &$0) }
+      """
     )
 
     assertParse(
       """
       { [weak a, unowned(safe) self, b = 3] (a: Int, b: Int, _: Int) -> Int in }
-      """,
-      { ExprSyntax.parse(from: &$0) }
+      """
     )
 
     assertParse(
       "ℹ️{[1️⃣class]in2️⃣",
-      { ExprSyntax.parse(from: &$0) },
       diagnostics: [
         DiagnosticSpec(
           locationMarker: "1️⃣",
@@ -121,15 +112,13 @@ final class TypeTests: ParserTestCase {
 
     assertParse(
       "{[n1️⃣`]in}",
-      { ExprSyntax.parse(from: &$0) },
       diagnostics: [
         DiagnosticSpec(message: "unexpected code '`' in closure capture clause")
       ]
     )
 
     assertParse(
       "{[weak1️⃣^]in}",
-      { ExprSyntax.parse(from: &$0) },
       diagnostics: [
         DiagnosticSpec(message: "expected identifier in closure capture", fixIts: ["insert identifier"]),
         DiagnosticSpec(message: "unexpected code '^' in closure capture clause"),
@@ -195,37 +184,34 @@ final class TypeTests: ParserTestCase {
 
   func testLowercaseSelf() {
     assertParse(
-      "1️⃣self2️⃣",
-      { TypeSyntax.parse(from: &$0) },
+      "let a: 1️⃣self",
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected 'self' keyword before type"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected type", fixIts: ["insert type"]),
+        DiagnosticSpec(message: "expected type in type annotation", fixIts: ["insert type"]),
+        DiagnosticSpec(message: "expected '=' in variable", fixIts: ["insert '='"]),
       ],
-      fixedSource: "<#type#>self"
+      fixedSource: "let a: <#type#> = self"
     )
   }
 
   func testUppercaseSelf() {
     assertParse(
-      "Self",
-      { TypeSyntax.parse(from: &$0) },
-      substructure: Syntax(TokenSyntax.keyword(.Self))
+      "let a: 1️⃣Self",
+      substructure: Syntax(TokenSyntax.keyword(.Self)),
+      substructureAfterMarker: "1️⃣"
     )
   }
 
   func testNestedLowercaseSelf() {
     assertParse(
-      "Foo.1️⃣self",
-      { TypeSyntax.parse(from: &$0) },
+      "let a: Foo.1️⃣self",
       substructure: Syntax(TokenSyntax.keyword(.`self`)),
       substructureAfterMarker: "1️⃣"
     )
   }
 
   func testNestedUppercaseSelf() {
     assertParse(
-      "Foo.1️⃣Self",
-      { TypeSyntax.parse(from: &$0) },
+      "let a: Foo.1️⃣Self",
       substructure: Syntax(TokenSyntax.identifier("Self")),
       substructureAfterMarker: "1️⃣"
     )