Introduce a library to handle user-defined operators

Package.swift

@@ -45,6 +45,8 @@ let package = Package(
     .macCatalyst(.v13),
   ],
   products: [
+    .library(name: "SwiftOperators", type: .static,
+             targets: ["SwiftOperators"]),
     .library(name: "SwiftParser", type: .static, targets: ["SwiftParser"]),
     .library(name: "SwiftSyntax", type: .static, targets: ["SwiftSyntax"]),
     .library(name: "SwiftSyntaxParser", type: .static, targets: ["SwiftSyntaxParser"]),
@@ -118,13 +120,19 @@ let package = Package(
         "DeclarationAttribute.swift.gyb",
       ]
     ),
+    .target(
+      name: "SwiftOperators",
+      dependencies: ["SwiftSyntax", "SwiftParser", "SwiftDiagnostics"]
+    ),
     .executableTarget(
       name: "lit-test-helper",
       dependencies: ["SwiftSyntax", "SwiftSyntaxParser"]
     ),
     .executableTarget(
       name: "swift-parser-test",
-      dependencies: ["SwiftDiagnostics", "SwiftSyntax", "SwiftParser", .product(name: "ArgumentParser", package: "swift-argument-parser")]
+      dependencies: ["SwiftDiagnostics", "SwiftSyntax", "SwiftParser",
+                     "SwiftOperators",
+                     .product(name: "ArgumentParser", package: "swift-argument-parser")]
     ),
     .executableTarget(
         name: "generate-swift-syntax-builder",
@@ -171,7 +179,13 @@ let package = Package(
     ),
     .testTarget(
       name: "SwiftParserTest",
-      dependencies: ["SwiftDiagnostics", "SwiftParser", "_SwiftSyntaxTestSupport"]
+      dependencies: ["SwiftDiagnostics", "SwiftOperators", "SwiftParser",
+                     "_SwiftSyntaxTestSupport"]
+    ),
+    .testTarget(
+      name: "SwiftOperatorsTest",
+      dependencies: ["SwiftOperators", "_SwiftSyntaxTestSupport",
+                     "SwiftParser"]
     ),
   ]
 )

Sources/SwiftOperators/Operator.swift

@@ -0,0 +1,57 @@
+//===------------------ Operator.swift ------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+/// Names an operator.
+///
+/// TODO: For now, we'll use strings, but we likely want to move this to a
+/// general notion of an Identifier.
+public typealias OperatorName = String
+
+/// Describes the kind of an operator.
+public enum OperatorKind: String {
+  /// Infix operator such as the + in a + b.
+  case infix
+
+  /// Prefix operator such as the - in -x.
+  case prefix
+
+  /// Postfix operator such as the ! in x!.
+  case postfix
+}
+
+/// Describes an operator.
+public struct Operator {
+  public let kind: OperatorKind
+  public let name: OperatorName
+  public let precedenceGroup: PrecedenceGroupName?
+  public let syntax: OperatorDeclSyntax?
+
+  public init(
+    kind: OperatorKind, name: OperatorName,
+    precedenceGroup: PrecedenceGroupName?,
+    syntax: OperatorDeclSyntax? = nil
+  ) {
+    self.kind = kind
+    self.name = name
+    self.precedenceGroup = precedenceGroup
+    self.syntax = syntax
+  }
+}
+
+extension Operator: CustomStringConvertible {
+  /// The description of an operator is the source code that produces it.
+  public var description: String {
+    (syntax ?? synthesizedSyntax()).description
+  }
+}

Sources/SwiftOperators/OperatorError+Diagnostics.swift

@@ -0,0 +1,75 @@
+//===------------------ OperatorError.swift ---------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftDiagnostics
+import SwiftParser
+import SwiftSyntax
+
+extension OperatorError : DiagnosticMessage {
+  public var severity: DiagnosticSeverity {
+    .error
+  }
+
+  public var message: String {
+    switch self {
+    case .groupAlreadyExists(let existing, _):
+      return "redefinition of precedence group '\(existing.name)'"
+
+    case .missingGroup(let groupName, _):
+      return "unknown precedence group '\(groupName)'"
+
+    case .operatorAlreadyExists(let existing, _):
+      return "redefinition of \(existing.kind) operator '\(existing.name)'"
+
+    case .missingOperator(let operatorName, _):
+      return "unknown infix operator '\(operatorName)'"
+
+    case .incomparableOperators(_, let leftGroup, _, let rightGroup):
+      if leftGroup == rightGroup {
+        return "adjacent operators are in non-associative precedence group '\(leftGroup)'"
+      }
+
+      return "adjacent operators are in unordered precedence groups '\(leftGroup)' and '\(rightGroup)'"
+    }
+  }
+
+  public var diagnosticID: MessageID {
+    MessageID(domain: "SwiftOperators", id: "\(self)")
+  }
+}
+
+extension OperatorError {
+  /// Produce the syntax node at which a diagnostic should be displayed.
+  var diagnosticDisplayNode: Syntax {
+    switch self {
+    case .incomparableOperators(let leftOperator, _, _, _):
+      return Syntax(leftOperator)
+
+    case .missingOperator(_, let node):
+      return node
+
+    case .operatorAlreadyExists(_, let newOperator):
+      return Syntax(newOperator.syntax ?? newOperator.synthesizedSyntax())
+
+    case .missingGroup(_, let node):
+      return node
+
+    case .groupAlreadyExists(_, let newGroup):
+      return Syntax(newGroup.syntax ?? newGroup.synthesizedSyntax())
+    }
+  }
+
+  /// Produce a diagnostic for a given operator-precedence error.
+  public var asDiagnostic: Diagnostic {
+    .init(node: diagnosticDisplayNode, message: self)
+  }
+}

Sources/SwiftOperators/OperatorError.swift

@@ -0,0 +1,45 @@
+//===------------------ OperatorError.swift ---------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+import SwiftSyntax
+
+/// Describes errors that can occur when working with user-defined operators.
+public enum OperatorError: Error {
+  /// Error produced when a given precedence group already exists in the
+  /// precedence graph.
+  case groupAlreadyExists(existing: PrecedenceGroup, new: PrecedenceGroup)
+
+  /// The named precedence group is missing from the precedence graph.
+  case missingGroup(PrecedenceGroupName, referencedFrom: Syntax)
+
+  /// Error produced when a given operator already exists.
+  case operatorAlreadyExists(existing: Operator, new: Operator)
+
+  /// The named operator is missing from the precedence graph.
+  case missingOperator(OperatorName, referencedFrom: Syntax)
+
+  /// No associativity relationship between operators.
+  case incomparableOperators(
+    leftOperator: ExprSyntax, leftPrecedenceGroup: PrecedenceGroupName,
+    rightOperator: ExprSyntax, rightPrecedenceGroup: PrecedenceGroupName
+  )
+}
+
+/// A function that receives an operator precedence error and may do with it
+/// whatever it likes.
+///
+/// Operator precedence error handlers are passed into each function in the
+/// operator-precedence parser that can produce a failure. The handler
+/// may choose to throw (in which case the error will propagate outward) or
+/// may separately record/drop the error and return without throwing (in
+/// which case the operator-precedence parser will recover).
+public typealias OperatorErrorHandler =
+    (OperatorError) throws -> Void