Rename OperatorPrecedenceError -> OperatorError.

More renaming for generalization.

Author: DougGregor

Sources/SwiftOperators/OperatorPrecedenceError+Diagnostics.swift renamed to Sources/SwiftOperators/OperatorError+Diagnostics.swift

@@ -1,4 +1,4 @@
-//===------------------ OperatorPrecedenceError.swift ---------------------===//
+//===------------------ OperatorError.swift ---------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -14,7 +14,7 @@ import SwiftDiagnostics
 import SwiftParser
 import SwiftSyntax
 
-extension OperatorPrecedenceError : DiagnosticMessage {
+extension OperatorError : DiagnosticMessage {
   public var severity: DiagnosticSeverity {
     .error
   }
@@ -47,7 +47,7 @@ extension OperatorPrecedenceError : DiagnosticMessage {
   }
 }
 
-extension OperatorPrecedenceError {
+extension OperatorError {
   private func fixupDiagnosticDisplayNode<Node: SyntaxProtocol>(
     _ node: Node?
   ) -> Syntax {

Sources/SwiftOperators/OperatorPrecedenceError.swift renamed to Sources/SwiftOperators/OperatorError.swift

@@ -1,4 +1,4 @@
-//===------------------ OperatorPrecedenceError.swift ---------------------===//
+//===------------------ OperatorError.swift ---------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -11,8 +11,8 @@
 //===----------------------------------------------------------------------===//
 import SwiftSyntax
 
-/// Describes errors that can occur when working with operator precedence graphs.
-public enum OperatorPrecedenceError: Error {
+/// 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)
@@ -41,5 +41,5 @@ public enum OperatorPrecedenceError: Error {
 /// 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 OperatorPrecedenceErrorHandler =
-    (OperatorPrecedenceError) throws -> Void
+public typealias OperatorErrorHandler =
+    (OperatorError) throws -> Void

Sources/SwiftOperators/OperatorTable+Folding.swift

@@ -31,7 +31,7 @@ extension OperatorTable {
     fromGroup groupName: PrecedenceGroupName?,
     in bound: PrecedenceBound,
     operatorSyntax: Syntax,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> Bool {
     guard let boundGroupName = bound.groupName else {
       return true
@@ -55,7 +55,7 @@ extension OperatorTable {
   /// Look up the precedence group for the given expression syntax.
   private func lookupPrecedence(
     of expr: ExprSyntax,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> PrecedenceGroupName? {
     // A binary operator.
     if let binaryExpr = expr.as(BinaryOperatorExprSyntax.self) {
@@ -180,7 +180,7 @@ extension OperatorTable {
     firstOperatorSyntax: Syntax?,
     secondGroup: PrecedenceGroupName?,
     secondOperatorSyntax: Syntax?,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> Associativity {
     guard let firstGroup = firstGroup, let secondGroup = secondGroup else {
       return .none
@@ -221,7 +221,7 @@ extension OperatorTable {
   private func fold(
     _ lhs: ExprSyntax, rest: inout Slice<ExprListSyntax>,
     bound: PrecedenceBound,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> ExprSyntax {
     if rest.isEmpty { return lhs }
 
@@ -378,7 +378,7 @@ extension OperatorTable {
   /// as if the expression has been parenthesized `x + (y * z)`.
   public func foldSingle(
     _ sequence: SequenceExprSyntax,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> ExprSyntax {
     let lhs = sequence.elements.first!
     var rest = sequence.elements.dropFirst()
@@ -394,14 +394,14 @@ extension OperatorTable {
   private class SequenceFolder : SyntaxRewriter {
     /// The first operator precedecence that caused the error handler to
     /// also throw.
-    var firstFatalError: OperatorPrecedenceError? = nil
+    var firstFatalError: OperatorError? = nil
 
     let opPrecedence: OperatorTable
-    let errorHandler: OperatorPrecedenceErrorHandler
+    let errorHandler: OperatorErrorHandler
 
     init(
       opPrecedence: OperatorTable,
-      errorHandler: @escaping OperatorPrecedenceErrorHandler
+      errorHandler: @escaping OperatorErrorHandler
     ) {
       self.opPrecedence = opPrecedence
       self.errorHandler = errorHandler
@@ -452,7 +452,7 @@ extension OperatorTable {
   /// the operation, then the second must also throw.
   public func foldAll<Node: SyntaxProtocol>(
     _ node: Node,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> SyntaxProtocol {
     return try withoutActuallyEscaping(errorHandler) { errorHandler in
       let folder = SequenceFolder(

Sources/SwiftOperators/OperatorTable+Semantics.swift

@@ -87,18 +87,18 @@ extension OperatorTable {
   /// source file into the operator precedence tables.
   public mutating func addSourceFile(
     _ sourceFile: SourceFileSyntax,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     class OperatorAndGroupVisitor : SyntaxAnyVisitor {
       var opPrecedence: OperatorTable
-      var errors: [OperatorPrecedenceError] = []
+      var errors: [OperatorError] = []
 
       init(opPrecedence: OperatorTable) {
         self.opPrecedence = opPrecedence
         super.init(viewMode: .fixedUp)
       }
 
-      private func errorHandler(error: OperatorPrecedenceError) {
+      private func errorHandler(error: OperatorError) {
         errors.append(error)
       }
 

Sources/SwiftOperators/OperatorTable.swift

@@ -32,7 +32,7 @@ public struct OperatorTable {
   public init(
     precedenceGroups: [PrecedenceGroup],
     operators: [Operator],
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     for group in precedenceGroups {
       try record(group, errorHandler: errorHandler)
@@ -46,7 +46,7 @@ public struct OperatorTable {
   private func record(
     _ op: Operator,
     in table: inout [OperatorName : Operator],
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     if let existing = table[op.name] {
       try errorHandler(.operatorAlreadyExists(existing: existing, new: op))
@@ -58,7 +58,7 @@ public struct OperatorTable {
   /// Record the operator.
   mutating func record(
     _ op: Operator,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     switch op.kind {
     case .infix:
@@ -75,7 +75,7 @@ public struct OperatorTable {
   /// Record the precedence group.
   mutating func record(
     _ group: PrecedenceGroup,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     try precedenceGraph.add(group, errorHandler: errorHandler)
   }
@@ -86,7 +86,7 @@ extension OperatorTable {
   func lookupOperatorPrecedenceGroupName(
     _ operatorName: OperatorName,
     referencedFrom syntax: Syntax?,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> PrecedenceGroupName? {
     guard let op = infixOperators[operatorName] else {
       try errorHandler(

Sources/SwiftOperators/PrecedenceGraph.swift

@@ -40,11 +40,11 @@ struct PrecedenceGraph {
   ///   throws PrecedenceGraphError.groupAlreadyExists.
   mutating func add(
     _ group: PrecedenceGroup,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows {
     if let existing = precedenceGroups[group.name] {
       try errorHandler(
-        OperatorPrecedenceError.groupAlreadyExists(
+        OperatorError.groupAlreadyExists(
           existing: existing, new: group))
     } else {
       precedenceGroups[group.name] = group
@@ -64,7 +64,7 @@ struct PrecedenceGraph {
     initialGroupName: PrecedenceGroupName, initialSyntax: Syntax?,
     targetGroupName: PrecedenceGroupName,
     direction: PrecedenceRelation.Kind,
-    errorHandler: OperatorPrecedenceErrorHandler
+    errorHandler: OperatorErrorHandler
   ) rethrows -> Precedence? {
     // Keep track of all of the groups we have seen during our exploration of
     // the graph. This detects cycles and prevents extraneous work.
@@ -116,7 +116,7 @@ struct PrecedenceGraph {
     to endGroupName: PrecedenceGroupName,
     startSyntax: Syntax?,
     endSyntax: Syntax?,
-    errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
+    errorHandler: OperatorErrorHandler = { throw $0 }
   ) rethrows -> Precedence {
     if startGroupName == endGroupName {
       return .unrelated

Sources/SwiftOperators/SwiftOperators.docc/SwiftOperators.md

@@ -78,10 +78,10 @@ dump(folded2) // contains InfixOperatorExpr(b, **, InfixOperatorExpr(c, **, d))
 
 ## Error handling
 
-By default, any of the operations that can produce an error, whether folding a sequence or parsing a source file's operators and precedence groups into a table, will throw an instance of <doc:OperatorPrecedenceError>. However, each entry point takes an optional error handler (of type <doc:OperatorPrecedenceErrorHandler>) that will be called with each error that occurs. For example, we can capture errors like this:
+By default, any of the operations that can produce an error, whether folding a sequence or parsing a source file's operators and precedence groups into a table, will throw an instance of <doc:OperatorError>. However, each entry point takes an optional error handler (of type <doc:OperatorErrorHandler>) that will be called with each error that occurs. For example, we can capture errors like this:
 
 ```swift
-var errors: [OperatorPrecedenceError] = []
+var errors: [OperatorError] = []
 let foldedExpr2e = opPrecedence.foldSingle(sequenceExpr2) { error in 
   errors.append(error)
 }

Tests/SwiftOperatorsTest/OperatorTable.swift

@@ -196,7 +196,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     let parsedOperatorPrecedence = try Parser.parse(source: sources)
 
     var opPrecedence = OperatorTable()
-    var errors: [OperatorPrecedenceError] = []
+    var errors: [OperatorError] = []
     opPrecedence.addSourceFile(parsedOperatorPrecedence) { error in
       errors.append(error)
     }
@@ -236,7 +236,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     let parsedOperatorPrecedence = try Parser.parse(source: sources)
 
     var opPrecedence = OperatorTable()
-    var errors: [OperatorPrecedenceError] = []
+    var errors: [OperatorError] = []
     opPrecedence.addSourceFile(parsedOperatorPrecedence) { error in
       errors.append(error)
     }
@@ -282,7 +282,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     try opPrecedence.addSourceFile(parsedOperatorPrecedence)
 
     do {
-      var errors: [OperatorPrecedenceError] = []
+      var errors: [OperatorError] = []
       let parsed = try Parser.parse(source: "a + b * c")
       let sequenceExpr =
         parsed.statements.first!.item.as(SequenceExprSyntax.self)!
@@ -301,7 +301,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     }
 
     do {
-      var errors: [OperatorPrecedenceError] = []
+      var errors: [OperatorError] = []
       let parsed = try Parser.parse(source: "a / c")
       let sequenceExpr =
         parsed.statements.first!.item.as(SequenceExprSyntax.self)!
@@ -320,7 +320,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     }
 
     do {
-      var errors: [OperatorPrecedenceError] = []
+      var errors: [OperatorError] = []
       let parsed = try Parser.parse(source: "a + b - c")
       let sequenceExpr =
         parsed.statements.first!.item.as(SequenceExprSyntax.self)!
@@ -342,7 +342,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     }
 
     do {
-      var errors: [OperatorPrecedenceError] = []
+      var errors: [OperatorError] = []
       let parsed = try Parser.parse(source: "a ++ b - d")
       let sequenceExpr =
         parsed.statements.first!.item.as(SequenceExprSyntax.self)!