Add diagnostic for missing 0 in RawFloatLiteralExprSyntax

Author: kimdv

Sources/SwiftParser/Expressions.swift

@@ -1263,6 +1263,29 @@ extension Parser {
       return RawExprSyntax(self.parseClosureExpression())
     case (.period, let handle)?:  // .foo
       let dot = self.eat(handle)
+
+      // Special case ".<integer_literal>" like ".4".  This isn't valid, but the
+      // developer almost certainly meant to use "0.4".  Diagnose this, and
+      // recover as if they wrote that.
+      if let integerLiteral = self.consume(if: .integerLiteral) {
+        return RawExprSyntax(
+          RawFloatLiteralExprSyntax(
+            floatingDigits: RawTokenSyntax(
+              missing: .floatingLiteral,
+              arena: self.arena
+            ),
+            RawUnexpectedNodesSyntax(
+              elements: [
+                RawSyntax(dot),
+                RawSyntax(integerLiteral),
+              ],
+              arena: self.arena
+            ),
+            arena: self.arena
+          )
+        )
+      }
+
       let (name, args) = self.parseDeclNameRef([.keywords, .compoundNames])
       return RawExprSyntax(
         RawMemberAccessExprSyntax(

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -678,6 +678,39 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if node.floatingDigits.presence == .missing,
+      let tokens = node.unexpectedAfterFloatingDigits?.onlyTokens(satisfying: { $0.tokenKind == .period || $0.tokenKind.isIntegerLiteral })
+    {
+      addDiagnostic(
+        node,
+        InvalidFloatLiteralMissingLeadingZero(integerLiteral: tokens[1]),
+        fixIts: [
+          FixIt(
+            message: InsertFixIt(tokenToBeInserted: .integerLiteral("0")),
+            changes: [
+              FixIt.MultiNodeChange(
+                FixIt.Change.replace(
+                  oldNode: Syntax(node.floatingDigits),
+                  newNode: Syntax(
+                    FloatLiteralExprSyntax(
+                      floatingDigits: .floatingLiteral("0.\(tokens[1].text)")
+                    )
+                  )
+                )
+              )
+            ] + tokens.map { FixIt.MultiNodeChange.makeMissing($0) }
+          )
+        ],
+        handledNodes: [node.floatingDigits.id] + tokens.map { $0.id }
+      )
+    }
+    return .visitChildren
+  }
+
   public override func visit(_ node: ForInStmtSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -306,6 +306,14 @@ public struct IdentifierNotAllowedInOperatorName: ParserError {
   }
 }
 
+public struct InvalidFloatLiteralMissingLeadingZero: ParserError {
+  public let integerLiteral: TokenSyntax
+
+  public var message: String {
+    return "'.\(integerLiteral.text)' is not a valid floating point literal; it must be written '0.\(integerLiteral.text)'"
+  }
+}
+
 public struct InvalidIdentifierError: ParserError {
   public let invalidIdentifier: TokenSyntax
   public let missingIdentifier: TokenSyntax

Sources/SwiftParserDiagnostics/SyntaxExtensions.swift

@@ -149,6 +149,15 @@ extension TokenKind {
       return false
     }
   }
+
+  var isIntegerLiteral: Bool {
+    switch self {
+    case .integerLiteral:
+      return true
+    default:
+      return false
+    }
+  }
 }
 
 public extension TriviaPiece {

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -1372,13 +1372,20 @@ final class RecoveryTests: XCTestCase {
     assertParse(
       """
       func exprPostfix2() {
-        _ = .1️⃣42
+        _ = 1️⃣.42
       }
       """,
       diagnostics: [
-        // TODO: Old parser expected error on line 2: '.42' is not a valid floating point literal; it must be written '0.42', Fix-It replacements: 7 - 7 = '0'
-        DiagnosticSpec(message: "expected name in member access", fixIts: ["insert name"])
-      ]
+        DiagnosticSpec(
+          message: "'.42' is not a valid floating point literal; it must be written '0.42'",
+          fixIts: ["insert '0'"]
+        )
+      ],
+      fixedSource: """
+        func exprPostfix2() {
+          _ = 0.42
+        }
+        """
     )
   }