Record prefix and postfix operators in the operator table.

At present, this only ends up checking for duplicate definitions.

Author: DougGregor

Sources/SwiftOperatorPrecedence/OperatorPrecedenceError+Diagnostics.swift

@@ -28,7 +28,7 @@ extension OperatorPrecedenceError : DiagnosticMessage {
       return "unknown precedence group '\(groupName)'"
 
     case .operatorAlreadyExists(let existing, _):
-      return "redefinition of infix operator '\(existing.name)'"
+      return "redefinition of \(existing.kind) operator '\(existing.name)'"
 
     case .missingOperator(let operatorName, _):
       return "unknown infix operator '\(operatorName)'"

Sources/SwiftOperatorPrecedence/OperatorTable.swift

@@ -21,7 +21,9 @@ import SwiftSyntax
 /// syntax tree.
 public struct OperatorTable {
   var precedenceGraph: PrecedenceGraph = .init()
-  var operators: [OperatorName : Operator] = [:]
+  var infixOperators: [OperatorName : Operator] = [:]
+  var prefixOperators: [OperatorName : Operator] = [:]
+  var postfixOperators: [OperatorName : Operator] = [:]
 
   public init() { }
 
@@ -40,19 +42,33 @@ public struct OperatorTable {
     }
   }
 
-  /// Record the operator, if it matters.
-  mutating func record(
+  /// Record the operator in the given operator array.
+  private func record(
     _ op: Operator,
+    in table: inout [OperatorName : Operator],
     errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
   ) rethrows {
-    // FIXME: Could do operator-already-exists checking for prefix/postfix
-    // operators as well, since we parse them.
-    if op.kind != .infix { return }
-
-    if let existing = operators[op.name] {
+    if let existing = table[op.name] {
       try errorHandler(.operatorAlreadyExists(existing: existing, new: op))
     } else {
-      operators[op.name] = op
+      table[op.name] = op
+    }
+  }
+
+  /// Record the operator.
+  mutating func record(
+    _ op: Operator,
+    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+  ) rethrows {
+    switch op.kind {
+    case .infix:
+      return try record(op, in: &infixOperators, errorHandler: errorHandler)
+
+    case .prefix:
+      return try record(op, in: &prefixOperators, errorHandler: errorHandler)
+
+    case .postfix:
+      return try record(op, in: &postfixOperators, errorHandler: errorHandler)
     }
   }
 
@@ -72,7 +88,7 @@ extension OperatorTable {
     referencedFrom syntax: Syntax?,
     errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
   ) rethrows -> PrecedenceGroupName? {
-    guard let op = operators[operatorName] else {
+    guard let op = infixOperators[operatorName] else {
       try errorHandler(
         .missingOperator(operatorName, referencedFrom: syntax))
       return nil

Tests/SwiftOperatorPrecedenceTest/OperatorTable.swift

@@ -220,6 +220,40 @@ public class OperatorPrecedenceTests: XCTestCase {
     _ = existingGroup
   }
 
+  func testUnaryErrors() throws {
+    let sources =
+      """
+      prefix operator +
+      prefix operator +
+
+      postfix operator -
+      prefix operator -
+
+      postfix operator*
+      postfix operator*
+      """
+
+    let parsedOperatorPrecedence = try Parser.parse(source: sources)
+
+    var opPrecedence = OperatorTable()
+    var errors: [OperatorPrecedenceError] = []
+    opPrecedence.addSourceFile(parsedOperatorPrecedence) { error in
+      errors.append(error)
+    }
+
+    XCTAssertEqual(errors.count, 2)
+    guard case let .operatorAlreadyExists(existing, new) = errors[0] else {
+      XCTFail("expected an 'operator already exists' error")
+      return
+    }
+
+    XCTAssertEqual(errors[0].message, "redefinition of prefix operator '+'")
+
+    XCTAssertEqual(errors[1].message, "redefinition of postfix operator '*'")
+    _ = existing
+    _ = new
+  }
+
   func testFoldErrors() throws {
     let parsedOperatorPrecedence = try Parser.parse(source:
       """