Improve diagnostics for invalid version tuples

Author: TTOzzi

Sources/SwiftParser/Availability.swift

@@ -253,6 +253,28 @@ extension Parser {
     return self.consumeAnyToken()
   }
 
+  /// Consume the unexpected version token(e.g. integerLiteral, floatingLiteral) until the period no longer appears.
+  private mutating func parseUnexpectedVersionTokens(unexpectedTokens: [RawSyntax] = []) -> RawUnexpectedNodesSyntax? {
+    var copiedUnexpectedTokens = unexpectedTokens
+    var keepGoing: RawTokenSyntax? = nil
+    var loopProgress = LoopProgressCondition()
+    repeat {
+      if let keepGoing {
+        copiedUnexpectedTokens.append(RawSyntax(keepGoing))
+      }
+      if let (_, handle) = self.at(anyIn: VersionTupleWhiteList.self) {
+        let versionToken = self.eat(handle)
+        copiedUnexpectedTokens.append(RawSyntax(versionToken))
+      }
+      keepGoing = self.consume(if: .period)
+    } while keepGoing != nil && loopProgress.evaluate(currentToken)
+
+    guard !copiedUnexpectedTokens.isEmpty else {
+      return nil
+    }
+    return RawUnexpectedNodesSyntax(elements: copiedUnexpectedTokens, arena: self.arena)
+  }
+
   /// Parse a dot-separated list of version numbers.
   ///
   /// Grammar
@@ -286,24 +308,28 @@ extension Parser {
         } else {
           trailingComponents.append(versionComponent)
         }
-      }
 
-      var unexpectedTrailingComponents: RawUnexpectedNodesSyntax?
-
-      if !trailingComponents.isEmpty {
-        unexpectedTrailingComponents = RawUnexpectedNodesSyntax(elements: trailingComponents.compactMap { $0.as(RawSyntax.self) }, arena: self.arena)
+        if version.isMissing {
+          break
+        }
       }
 
+      let unexpectedAfterComponents = self.parseUnexpectedVersionTokens(unexpectedTokens: trailingComponents.map(RawSyntax.init))
       return RawVersionTupleSyntax(
         major: major,
         components: RawVersionComponentListSyntax(elements: components, arena: self.arena),
-        unexpectedTrailingComponents,
+        unexpectedAfterComponents,
         arena: self.arena
       )
-
     } else {
       let major = self.expectDecimalIntegerWithoutRecovery()
-      return RawVersionTupleSyntax(major: major, components: nil, arena: self.arena)
+      let unexpectedAfterComponents = self.parseUnexpectedVersionTokens()
+      return RawVersionTupleSyntax(
+        major: major,
+        components: nil,
+        unexpectedAfterComponents,
+        arena: self.arena
+      )
     }
   }
 }

Sources/SwiftParser/TokenSpecSet.swift

@@ -901,3 +901,28 @@ enum EffectSpecifiers: TokenSpecSet {
     }
   }
 }
+
+enum VersionTupleWhiteList: TokenSpecSet {
+  case integerLiteral
+  case floatingLiteral
+
+  init?(lexeme: Lexer.Lexeme) {
+    switch PrepareForKeywordMatch(lexeme) {
+    case TokenSpec(.integerLiteral):
+      self = .integerLiteral
+    case TokenSpec(.floatingLiteral):
+      self = .floatingLiteral
+    default:
+      return nil
+    }
+  }
+
+  var spec: TokenSpec {
+    switch self {
+    case .integerLiteral:
+      return .integerLiteral
+    case .floatingLiteral:
+      return .floatingLiteral
+    }
+  }
+}

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1893,14 +1893,31 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       return .skipChildren
     }
 
-    if let trailingComponents = node.unexpectedAfterComponents,
-      let components = node.components
-    {
-      addDiagnostic(
-        trailingComponents,
-        TrailingVersionAreIgnored(major: node.major, components: components),
-        handledNodes: [trailingComponents.id]
-      )
+    if let unexpectedAfterComponents = node.unexpectedAfterComponents {
+      if let components = node.components,
+        unexpectedAfterComponents.allSatisfy({ $0.is(VersionComponentSyntax.self) })
+      {
+        addDiagnostic(
+          unexpectedAfterComponents,
+          TrailingVersionAreIgnored(major: node.major, components: components),
+          handledNodes: [unexpectedAfterComponents.id]
+        )
+      } else {
+        var handledNodes: [SyntaxIdentifier] = [unexpectedAfterComponents.id]
+        if node.major.hasError {
+          handledNodes.append(node.major.id)
+        }
+        if let components = node.components,
+          components.hasError
+        {
+          handledNodes.append(components.id)
+        }
+        addDiagnostic(
+          unexpectedAfterComponents,
+          CannotParseVersionTuple(versionTuple: unexpectedAfterComponents),
+          handledNodes: handledNodes
+        )
+      }
     }
 
     return .visitChildren

Tests/SwiftParserTest/AvailabilityTests.swift

@@ -142,19 +142,21 @@ final class AvailabilityTests: XCTestCase {
       )
     )
 
+    assertParse(
+      """
+      @available(OSX 10.0.1, *)
+      func test() {}
+      """
+    )
+
     assertParse(
       """
       @available(OSX 1️⃣10e10)
       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(
@@ -163,13 +165,8 @@ final class AvailabilityTests: XCTestCase {
       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 0e10")
+      ]
     )
 
     assertParse(
@@ -178,26 +175,41 @@ 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)
       func test() {}
       """,
+      diagnostics: [
+        DiagnosticSpec(message: "cannot parse version 0xff")
+      ]
+    )
+
+    assertParse(
+      """
+      @available(OSX 1.0.1️⃣0xff, *)
+      func test() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "cannot parse version 0xff")
+      ]
+    )
+
+    assertParse(
+      """
+      @available(OSX 1.0.1️⃣asdf)
+      func test() {}
+      """,
       diagnostics: [
         DiagnosticSpec(message: "expected integer literal in version tuple", fixIts: ["insert integer literal"]),
-        DiagnosticSpec(message: "unexpected code '0xff' in attribute"),
+        DiagnosticSpec(message: "unexpected code 'asdf' in attribute"),
       ],
       fixedSource: """
-        @available(OSX 1.0.<#integer literal#>0xff)
+        @available(OSX 1.0.<#integer literal#>asdf)
         func test() {}
         """
     )