Improve diagnostics for invalid version tuples

Author: TTOzzi

Sources/SwiftParser/Availability.swift

@@ -262,48 +262,97 @@ extension Parser {
   ///     version-list -> version-tuple-element version-list?
   ///     version-tuple-element -> '.' interger-literal
   mutating func parseVersionTuple(maxComponentCount: Int) -> RawVersionTupleSyntax {
-    if self.at(.floatingLiteral),
-      let periodIndex = self.currentToken.tokenText.firstIndex(of: UInt8(ascii: ".")),
-      self.currentToken.tokenText[0..<periodIndex].allSatisfy({ Unicode.Scalar($0).isDigit })
-    {
-      // The lexer generates a float literal '1.2' for the major and minor version.
-      // Split it into two integers if possible
-      let major = self.consumePrefix(SyntaxText(rebasing: self.currentToken.tokenText[0..<periodIndex]), as: .integerLiteral)
+    if self.at(.floatingLiteral) {
 
-      var components: [RawVersionComponentSyntax] = []
-      var trailingComponents: [RawVersionComponentSyntax] = []
+      if let periodIndex = self.currentToken.tokenText.firstIndex(of: UInt8(ascii: ".")),
+        self.currentToken.tokenText[0..<periodIndex].allSatisfy({ Unicode.Scalar($0).isDigit })
+      {
+        // The lexer generates a float literal '1.2' for the major and minor version.
+        // Split it into two integers if possible
+        let major = self.consumePrefix(SyntaxText(rebasing: self.currentToken.tokenText[0..<periodIndex]), as: .integerLiteral)
 
-      for i in 1... {
-        guard let period = self.consume(if: .period) else {
-          break
-        }
-        let version = self.expectDecimalIntegerWithoutRecovery()
+        var components: [RawVersionComponentSyntax] = []
+        var trailingComponents: [RawVersionComponentSyntax] = []
 
-        let versionComponent = RawVersionComponentSyntax(period: period, number: version, arena: self.arena)
+        for i in 1... {
+          guard let period = self.consume(if: .period) else {
+            break
+          }
+          let version = self.expectDecimalIntegerWithoutRecovery()
 
-        if i < maxComponentCount {
-          components.append(versionComponent)
-        } else {
-          trailingComponents.append(versionComponent)
-        }
-      }
+          let versionComponent = RawVersionComponentSyntax(period: period, number: version, arena: self.arena)
 
-      var unexpectedTrailingComponents: RawUnexpectedNodesSyntax?
+          if i < maxComponentCount {
+            components.append(versionComponent)
+          } else {
+            trailingComponents.append(versionComponent)
+          }
 
-      if !trailingComponents.isEmpty {
-        unexpectedTrailingComponents = RawUnexpectedNodesSyntax(elements: trailingComponents.compactMap { $0.as(RawSyntax.self) }, arena: self.arena)
-      }
+          if versionComponent.hasError {
+            let unexpectedComponents = components + trailingComponents
+            var unexpectedTokens = [RawSyntax(major)] + unexpectedComponents.map(RawSyntax.init)
+            if let (_, handle) = self.canRecoverTo(anyIn: VersionTupleSyntax.EndOfVersionTupleOptions.self) {
+              for _ in 0..<handle.unexpectedTokens {
+                unexpectedTokens.append(RawSyntax(self.consumeAnyToken()))
+              }
+            }
+            return RawVersionTupleSyntax(
+              RawUnexpectedNodesSyntax(unexpectedTokens, arena: self.arena),
+              major: self.missingToken(.integerLiteral, text: nil),
+              components: nil,
+              arena: self.arena
+            )
+          }
+        }
 
-      return RawVersionTupleSyntax(
-        major: major,
-        components: RawVersionComponentListSyntax(elements: components, arena: self.arena),
-        unexpectedTrailingComponents,
-        arena: self.arena
-      )
+        var unexpectedTrailingComponents: RawUnexpectedNodesSyntax?
 
+        if !trailingComponents.isEmpty {
+          unexpectedTrailingComponents = RawUnexpectedNodesSyntax(elements: trailingComponents.compactMap { $0.as(RawSyntax.self) }, arena: self.arena)
+        }
+
+        return RawVersionTupleSyntax(
+          major: major,
+          components: RawVersionComponentListSyntax(elements: components, arena: self.arena),
+          unexpectedTrailingComponents,
+          arena: self.arena
+        )
+      } else {
+        let unexpectedToken = self.eat(.floatingLiteral)
+        return RawVersionTupleSyntax(
+          RawUnexpectedNodesSyntax([unexpectedToken], arena: self.arena),
+          major: self.missingToken(.integerLiteral, text: nil),
+          components: nil,
+          arena: self.arena
+        )
+      }
     } else {
       let major = self.expectDecimalIntegerWithoutRecovery()
-      return RawVersionTupleSyntax(major: major, components: nil, arena: self.arena)
+      if major.hasError {
+        let unexpectedNodes: RawUnexpectedNodesSyntax?
+        var unexpectedTokens = [RawSyntax]()
+        if !major.isEmpty {
+          unexpectedTokens.append(RawSyntax(major))
+        }
+        if let (_, handle) = self.canRecoverTo(anyIn: VersionTupleSyntax.EndOfVersionTupleOptions.self) {
+          for _ in 0..<handle.unexpectedTokens {
+            unexpectedTokens.append(RawSyntax(self.consumeAnyToken()))
+          }
+        }
+        if !unexpectedTokens.isEmpty {
+          unexpectedNodes = RawUnexpectedNodesSyntax(elements: unexpectedTokens, arena: self.arena)
+        } else {
+          unexpectedNodes = nil
+        }
+        return RawVersionTupleSyntax(
+          unexpectedNodes,
+          major: self.missingToken(.integerLiteral, text: nil),
+          components: nil,
+          arena: self.arena
+        )
+      } else {
+        return RawVersionTupleSyntax(major: major, components: nil, arena: self.arena)
+      }
     }
   }
 }

Sources/SwiftParser/generated/Parser+TokenSpecSet.swift

@@ -2084,3 +2084,30 @@ extension VariableDeclSyntax {
     }
   }
 }
+
+extension VersionTupleSyntax {
+  enum EndOfVersionTupleOptions: TokenSpecSet {
+    case comma
+    case rightParen
+    
+    init?(lexeme: Lexer.Lexeme) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.comma):
+        self = .comma
+      case TokenSpec(.rightParen):
+        self = .rightParen
+      default:
+        return nil
+      }
+    }
+    
+    var spec: TokenSpec {
+      switch self {
+      case .comma:
+        return .comma
+      case .rightParen:
+        return .rightParen
+      }
+    }
+  }
+}

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1893,6 +1893,16 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       return .skipChildren
     }
 
+    if let unexpectedBeforeMajor = node.unexpectedBeforeMajor,
+      node.major.isMissing
+    {
+      addDiagnostic(
+        unexpectedBeforeMajor,
+        CannotParseVersionTuple(versionTuple: unexpectedBeforeMajor),
+        handledNodes: [unexpectedBeforeMajor.id, node.major.id]
+      )
+    }
+
     if let trailingComponents = node.unexpectedAfterComponents,
       let components = node.components
     {

Tests/SwiftParserTest/AvailabilityTests.swift

@@ -148,28 +148,18 @@ final class AvailabilityTests: XCTestCase {
       func test() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected version tuple in version restriction", fixIts: ["insert version tuple"]),
-        DiagnosticSpec(message: "unexpected code '10e10' in attribute"),
-      ],
-      fixedSource: """
-        @available(OSX <#integer literal#>10e10)
-        func test() {}
-        """
+        DiagnosticSpec(message: "cannot parse version 10e10")
+      ]
     )
 
     assertParse(
       """
-      @available(OSX 10.1️⃣0e10)
+      @available(OSX 1️⃣10.0e10)
       func test() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected integer literal in version tuple", fixIts: ["insert integer literal"]),
-        DiagnosticSpec(message: "unexpected code '0e10' in attribute"),
-      ],
-      fixedSource: """
-        @available(OSX 10.<#integer literal#>0e10)
-        func test() {}
-        """
+        DiagnosticSpec(message: "cannot parse version 10.0e10")
+      ]
     )
 
     assertParse(
@@ -178,28 +168,38 @@ final class AvailabilityTests: XCTestCase {
       func test() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected version tuple in version restriction", fixIts: ["insert version tuple"]),
-        DiagnosticSpec(message: "unexpected code '0xff' in attribute"),
-      ],
-      fixedSource: """
-        @available(OSX <#integer literal#>0xff)
-        func test() {}
-        """
+        DiagnosticSpec(message: "cannot parse version 0xff")
+      ]
     )
 
     assertParse(
       """
-      @available(OSX 1.0.1️⃣0xff)
+      @available(OSX 1️⃣1.0.0xff)
       func test() {}
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected integer literal in version tuple", fixIts: ["insert integer literal"]),
-        DiagnosticSpec(message: "unexpected code '0xff' in attribute"),
-      ],
-      fixedSource: """
-        @available(OSX 1.0.<#integer literal#>0xff)
-        func test() {}
-        """
+        DiagnosticSpec(message: "cannot parse version 1.0.0xff")
+      ]
+    )
+
+    assertParse(
+      """
+      @available(OSX 1️⃣1.0.0xff, *)
+      func test() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "cannot parse version 1.0.0xff")
+      ]
+    )
+
+    assertParse(
+      """
+      @available(OSX 1️⃣1.0.0xff *)
+      func test() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "cannot parse version 1.0.0xff *")
+      ]
     )
   }
 }