Add diagnostic for missing 0 in RawFloatLiteralExprSyntax

Sources/SwiftParser/Expressions.swift

@@ -1263,6 +1263,31 @@ 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) {
+        let text = arena.intern("0" + String(syntaxText: dot.tokenText) + String(syntaxText: integerLiteral.tokenText))
+        return RawExprSyntax(
+          RawFloatLiteralExprSyntax(
+            floatingDigits: RawTokenSyntax(
+              missing: .floatingLiteral,
+              text: text,
+              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,32 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: FloatLiteralExprSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+    if node.floatingDigits.presence == .missing,
+      let (period, integerLiteral) = node.unexpectedAfterFloatingDigits?.twoTokens(firstSatisfying: { $0.tokenKind == .period }, secondSatisfying: { $0.tokenKind.isIntegerLiteral })
+    {
+      addDiagnostic(
+        node,
+        InvalidFloatLiteralMissingLeadingZero(decimalDigits: integerLiteral),
+        fixIts: [
+          FixIt(
+            message: InsertFixIt(tokenToBeInserted: .integerLiteral("0")),
+            changes: [
+              .makePresent(node.floatingDigits),
+              .makeMissing(period),
+              .makeMissing(integerLiteral),
+            ]
+          )
+        ],
+        handledNodes: [node.floatingDigits.id, period.id, integerLiteral.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 decimalDigits: TokenSyntax
+
+  public var message: String {
+    return "'.\(decimalDigits.text)' is not a valid floating point literal; it must be written '0.\(decimalDigits.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 {

Sources/SwiftSyntax/SyntaxArena.swift

@@ -79,7 +79,8 @@ public class SyntaxArena {
 
   /// Copies a UTF8 sequence of `String` to the memory this arena manages, and
   /// returns the copied string as a `SyntaxText`
-  func intern(_ value: String) -> SyntaxText {
+  @_spi(RawSyntax)
+  public func intern(_ value: String) -> SyntaxText {
     if value.isEmpty { return SyntaxText() }
     var value = value
     return value.withUTF8 { utf8 in

Tests/SwiftParserTest/translated/RecoveryTests.swift

@@ -1658,16 +1658,18 @@ 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() {
-          _ = .<#identifier#>42
+          _ = 0.42
         }
         """
     )