Improve FixIt for function param with missing type

If the `node.secondName` starts with a capital letter, we now assume the user
wanted it to be the type of the parameter.

This commit makes the following changes to the FixIt of `name1 Name2`:
- from `name1 Name2: TypeText`
- to `name1: Name2`

Author: TiagoMaiaL

Sources/SwiftParser/Parameters.swift

@@ -92,10 +92,39 @@ extension Parser {
     let modifiers = parseParameterModifiers(isClosure: false)
     let misplacedSpecifiers = parseMisplacedSpecifiers()
 
-    let names = self.parseParameterNames()
-    let (unexpectedBeforeColon, colon) = self.expect(.colon)
-
-    let type = self.parseType(misplacedSpecifiers: misplacedSpecifiers)
+    var names = self.parseParameterNames()
+    var (unexpectedBeforeColon, colon) = self.expect(.colon)
+    
+    let type: RawTypeSyntax
+    
+    if colon.presence == .missing, let secondName = names.secondName, secondName.tokenText.isStartingWithUppercase {
+      // Synthesize the secondName parameter as a type node.
+      type = RawTypeSyntax(
+        RawSimpleTypeIdentifierSyntax(
+          name: RawTokenSyntax(
+            kind: .identifier,
+            text: secondName.tokenText,
+            presence: .missing,
+            arena: self.arena
+          ),
+          genericArgumentClause: nil,
+          arena: self.arena
+        )
+      )
+      unexpectedBeforeColon = RawUnexpectedNodesSyntax(
+        combining: unexpectedBeforeColon, names.secondName,
+        arena: self.arena
+      )
+      names = ParameterNames(
+        unexpectedBeforeFirstName: names.unexpectedBeforeFirstName,
+        firstName: names.firstName,
+        unexpectedBeforeSecondName: nil,
+        secondName: nil
+      )
+    } else {
+      // Parse the type node as we would normally do.
+      type = self.parseType(misplacedSpecifiers: misplacedSpecifiers)
+    }
 
     let ellipsis = self.consumeIfContextualPunctuator("...", remapping: .ellipsis)
 

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -797,6 +797,27 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       moveFixIt: { MoveTokensInFrontOfTypeFixIt(movedTokens: $0) },
       removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) }
     )
+    if let unexpectedBeforeColon = node.unexpectedBetweenSecondNameAndColon, node.colon.presence == .missing, node.type.isMissingAllTokens {
+      addDiagnostic(
+        unexpectedBeforeColon,
+        StaticParserError.expectedColonAndType,
+        fixIts: [
+          FixIt(
+            message: StaticParserFixIt.insertColonAndType,
+            changes: [
+              .makeMissing(unexpectedBeforeColon),
+              .makePresent(node.colon, leadingTrivia: nil),
+              .makePresent(node.type)
+            ]
+          )
+        ],
+        handledNodes: [
+          unexpectedBeforeColon.id,
+          node.colon.id,
+          node.type.id
+        ]
+      )
+    }
     return .visitChildren
   }
 

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -135,6 +135,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var expectedColonClass: Self {
     .init("expected ':' to begin inheritance clause")
   }
+  public static var expectedColonAndType: Self {
+    .init("expected ':' and type in parameter")
+  }
   public static var expectedExpressionAfterTry: Self {
     .init("expected expression after 'try'")
   }
@@ -556,6 +559,9 @@ extension FixItMessage where Self == StaticParserFixIt {
   public static var insertSemicolon: Self {
     .init("insert ';'")
   }
+  public static var insertColonAndType: Self {
+    .init("insert ':' and type")
+  }
   public static var insertAttributeArguments: Self {
     .init("insert attribute argument")
   }

Tests/SwiftParserTest/translated/InvalidTests.swift

@@ -305,14 +305,17 @@ final class InvalidTests: XCTestCase {
   }
 
   func testInvalid13() {
+    // TODO: Determine if the comment below should be removed.
     // https://github.com/apple/swift/issues/43190
     // Crash with invalid parameter declaration
+    
+    // TODO: Remove the trailing trivia from the firstName node (`s` and space).
     assertParse(
       """
       do {
         class Starfish {}
         struct Salmon {}
-        func f(s Starfish1️⃣,
+        func f(s 1️⃣Starfish,
                   _ ss: Salmon) -> [Int] {}
         func g() { f(Starfish(), Salmon()) }
       }
@@ -324,7 +327,7 @@ final class InvalidTests: XCTestCase {
         do {
           class Starfish {}
           struct Salmon {}
-          func f(s Starfish: <#type#>,
+          func f(s : Starfish,
                     _ ss: Salmon) -> [Int] {}
           func g() { f(Starfish(), Salmon()) }
         }