Classify Operator Identifiers

Author: CodaFi

Sources/SwiftSyntax/gyb_generated/SyntaxClassification.swift

@@ -23,6 +23,8 @@ public enum SyntaxClassification {
   case typeIdentifier
   /// An identifier starting with `$` like `$0`. 
   case dollarIdentifier
+  /// An identifier referring to an operator.
+  case operatorIdentifier
   /// An integer literal. 
   case integerLiteral
   /// A floating point literal. 
@@ -41,7 +43,7 @@ public enum SyntaxClassification {
   case objectLiteral
   /// An editor placeholder of the form `<#content#>` 
   case editorPlaceholder
-  /// A line comment starting with `//`. 
+  /// A line comment starting with `//`.
   case lineComment
   /// A doc line comment starting with `///`. 
   case docLineComment
@@ -87,6 +89,8 @@ extension SyntaxClassification {
         return (.typeIdentifier, false)
       case (.memberTypeIdentifier, 5):
         return (.typeIdentifier, false)
+      case (.operatorDecl, 1):
+        return (.operatorIdentifier, false)
       case (.constrainedSugarType, 1):
         return (.keyword, false)
       case (.availabilityVersionRestriction, 1):
@@ -343,9 +347,9 @@ extension RawTokenKind {
     case .identifier:
       return .identifier
     case .unspacedBinaryOperator:
-      return .none
+      return .operatorIdentifier
     case .spacedBinaryOperator:
-      return .none
+      return .operatorIdentifier
     case .postfixOperator:
       return .none
     case .prefixOperator:

Sources/lit-test-helper/ClassifiedSyntaxTreePrinter.swift

@@ -21,6 +21,7 @@ extension SyntaxClassification {
     case .identifier: return "id"
     case .typeIdentifier: return "type"
     case .dollarIdentifier: return "dollar"
+    case .operatorIdentifier: return "op"
     case .integerLiteral: return "int"
     case .floatingLiteral: return "float"
     case .stringLiteral: return "str"

Tests/SwiftParserTest/ClassificationTests.swift

@@ -121,4 +121,56 @@ public class ClassificationTests: XCTestCase {
       XCTAssertEqual(classif.kind, .typeIdentifier)
     }
   }
+
+  public func testOperatorTokenClassification() {
+    do {
+      let source = "let x: Int = 4 + 5 / 6"
+      let tree = Parser.parse(source: source)
+
+      let tokens = Array(tree.tokens(viewMode: .sourceAccurate))
+      XCTAssertEqual(tokens.count, 10)
+      guard tokens.count == 10 else {
+        return
+      }
+      let classif = tokens.map { $0.tokenClassification }
+      XCTAssertEqual(classif[0].kind, .keyword)
+      XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 3))
+      XCTAssertEqual(classif[1].kind, .identifier)
+      XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 4, length: 1))
+      XCTAssertEqual(classif[2].kind, .none)
+      XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 5, length: 1))
+      XCTAssertEqual(classif[3].kind, .typeIdentifier)
+      XCTAssertEqual(classif[3].range, ByteSourceRange(offset: 7, length: 3))
+      XCTAssertEqual(classif[4].kind, .none)
+      XCTAssertEqual(classif[4].range, ByteSourceRange(offset: 11, length: 1))
+      XCTAssertEqual(classif[5].kind, .integerLiteral)
+      XCTAssertEqual(classif[5].range, ByteSourceRange(offset: 13, length: 1))
+      XCTAssertEqual(classif[6].kind, .operatorIdentifier)
+      XCTAssertEqual(classif[6].range, ByteSourceRange(offset: 15, length: 1))
+      XCTAssertEqual(classif[7].kind, .integerLiteral)
+      XCTAssertEqual(classif[7].range, ByteSourceRange(offset: 17, length: 1))
+      XCTAssertEqual(classif[8].kind, .operatorIdentifier)
+      XCTAssertEqual(classif[8].range, ByteSourceRange(offset: 19, length: 1))
+      XCTAssertEqual(classif[9].kind, .integerLiteral)
+      XCTAssertEqual(classif[9].range, ByteSourceRange(offset: 21, length: 1))
+    }
+
+    do {
+      let source = "infix operator *--*"
+      let tree = Parser.parse(source: source)
+
+      let tokens = Array(tree.tokens(viewMode: .sourceAccurate))
+      XCTAssertEqual(tokens.count, 3)
+      guard tokens.count == 3 else {
+        return
+      }
+      let classif = tokens.map { $0.tokenClassification }
+      XCTAssertEqual(classif[0].kind, .keyword)
+      XCTAssertEqual(classif[0].range, ByteSourceRange(offset: 0, length: 5))
+      XCTAssertEqual(classif[1].kind, .keyword)
+      XCTAssertEqual(classif[1].range, ByteSourceRange(offset: 6, length: 8))
+      XCTAssertEqual(classif[2].kind, .operatorIdentifier)
+      XCTAssertEqual(classif[2].range, ByteSourceRange(offset: 15, length: 4))
+    }
+  }
 }