Detect and add a fix-it for using : instead of -> in a function

Author: j-f1

Sources/SwiftParser/Declarations.swift

@@ -1337,9 +1337,24 @@ extension Parser {
   /// If a `throws` keyword appears right in front of the `arrow`, it is returned as `misplacedThrowsKeyword` so it can be synthesized in front of the arrow.
   mutating func parseFunctionReturnClause(
     effectSpecifiers: inout (some RawMisplacedEffectSpecifiersTrait)?,
-    allowNamedOpaqueResultType: Bool
+    allowNamedOpaqueResultType: Bool,
+    unexpectedColon: RawTokenSyntax? = nil
   ) -> RawReturnClauseSyntax {
-    let (unexpectedBeforeArrow, arrow) = self.expect(.arrow)
+    let unexpectedBeforeArrow: RawUnexpectedNodesSyntax?
+    let arrow: RawTokenSyntax
+    if let unexpectedColon {
+      let diagnostic = TokenDiagnostic(
+        .expectedArrowBeforeReturnType,
+        byteOffset: unexpectedColon.leadingTriviaByteLength
+      )
+      unexpectedBeforeArrow = nil
+      arrow = unexpectedColon.tokenView.withTokenDiagnostic(
+        tokenDiagnostic: diagnostic,
+        arena: arena
+      )
+    } else {
+      (unexpectedBeforeArrow, arrow) = self.expect(.arrow)
+    }
     let unexpectedBeforeReturnType = self.parseMisplacedEffectSpecifiers(&effectSpecifiers)
     let type: RawTypeSyntax
     if allowNamedOpaqueResultType {
@@ -1440,6 +1455,12 @@ extension Parser {
         effectSpecifiers: &effectSpecifiers,
         allowNamedOpaqueResultType: true
       )
+    } else if let colon = self.consume(if: .colon) {
+      returnClause = self.parseFunctionReturnClause(
+        effectSpecifiers: &effectSpecifiers,
+        allowNamedOpaqueResultType: true,
+        unexpectedColon: colon
+      )
     } else {
       returnClause = nil
     }

Sources/SwiftParserDiagnostics/LexerDiagnosticMessages.swift

@@ -65,6 +65,7 @@ extension TokenWarning {
 /// Please order the cases in this enum alphabetically by case name.
 public enum StaticTokenError: String, DiagnosticMessage {
   case editorPlaceholder = "editor placeholder in source file"
+  case expectedArrowBeforeReturnType = "expected '->' before return type"
   case equalMustHaveConsistentWhitespaceOnBothSides = "'=' must have consistent whitespace on both sides"
   case expectedBinaryExponentInHexFloatLiteral = "hexadecimal floating point literal must end with an exponent"
   case expectedClosingBraceInUnicodeEscape = #"expected '}' in \u{...} escape sequence"#
@@ -198,6 +199,8 @@ extension SwiftSyntax.TokenDiagnostic {
 
     switch self.kind {
     case .editorPlaceholder: return StaticTokenError.editorPlaceholder
+    case .expectedArrowBeforeReturnType:
+      return StaticTokenError.expectedArrowBeforeReturnType
     case .equalMustHaveConsistentWhitespaceOnBothSides:
       return StaticTokenError.equalMustHaveConsistentWhitespaceOnBothSides
     case .expectedBinaryExponentInHexFloatLiteral: return StaticTokenError.expectedBinaryExponentInHexFloatLiteral
@@ -301,6 +304,19 @@ extension SwiftSyntax.TokenDiagnostic {
           changes: [.replace(oldNode: Syntax(token), newNode: Syntax(fixedToken))]
         )
       ]
+    case .expectedArrowBeforeReturnType:
+      var fixedToken = token.with(\.tokenKind, .arrow)
+      if let previous = fixedToken.previousToken(viewMode: .sourceAccurate),
+         previous.trailingTrivia.isEmpty,
+         fixedToken.leadingTrivia.isEmpty {
+        fixedToken.leadingTrivia = .space
+      }
+      return [
+        FixIt(
+          message: .replaceColonWithArrow,
+          changes: [.replace(oldNode: Syntax(token), newNode: Syntax(fixedToken))]
+        )
+      ]
     case .equalMustHaveConsistentWhitespaceOnBothSides:
       let hasLeadingSpace =
         token.previousToken(viewMode: .all)?.trailingTrivia.contains(where: { $0.isSpaceOrTab }) ?? false

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -730,6 +730,9 @@ extension FixItMessage where Self == StaticParserFixIt {
   public static var replaceCurlyQuoteByNormalQuote: Self {
     .init(#"replace curly quotes with '"'"#)
   }
+  public static var replaceColonWithArrow: Self {
+    .init("replace ':' with '->'")
+  }
   public static var replaceNonBreakingSpaceBySpace: Self {
     .init("replace non-breaking space with ' '")
   }

Sources/SwiftSyntax/TokenDiagnostic.swift

@@ -25,6 +25,7 @@ public struct TokenDiagnostic: Hashable, Sendable {
 
     case editorPlaceholder
     case equalMustHaveConsistentWhitespaceOnBothSides
+    case expectedArrowBeforeReturnType
     case expectedBinaryExponentInHexFloatLiteral
     case expectedClosingBraceInUnicodeEscape
     case expectedDigitInFloatLiteral
@@ -69,6 +70,7 @@ public struct TokenDiagnostic: Hashable, Sendable {
       switch self {
       case .editorPlaceholder: return .error
       case .equalMustHaveConsistentWhitespaceOnBothSides: return .error
+      case .expectedArrowBeforeReturnType: return .error
       case .expectedBinaryExponentInHexFloatLiteral: return .error
       case .expectedClosingBraceInUnicodeEscape: return .error
       case .expectedDigitInFloatLiteral: return .error

Tests/SwiftParserTest/DeclarationTests.swift

@@ -156,6 +156,58 @@ final class DeclarationTests: ParserTestCase {
     )
   }
 
+  func testFuncColonInsteadOfArrow() {
+    assertParse(
+      """
+      func foo()1️⃣: Slice<MinimalMutableCollection<T>> {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '->' before return type",
+          fixIts: ["replace ':' with '->'"]
+        )
+      ],
+      fixedSource: """
+      func foo() -> Slice<MinimalMutableCollection<T>> {}
+      """
+    )
+
+    assertParse(
+      """
+      func foo() 1️⃣: [String] {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '->' before return type",
+          fixIts: ["replace ':' with '->'"]
+        )
+      ],
+      fixedSource: """
+      func foo() -> [String] {}
+      """
+    )
+
+    assertParse(
+      """
+      func foo<T>() async throws
+        1️⃣: Int where T: Hashable {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected '->' before return type",
+          fixIts: ["replace ':' with '->'"]
+        )
+      ],
+      fixedSource: """
+      func foo<T>() async throws
+        -> Int where T: Hashable {}
+      """
+    )
+  }
+
   func testFuncAfterUnbalancedClosingBrace() {
     assertParse(
       """