Rename OperatorPrecedence to OperatorTable and improve its documentation.

Author: DougGregor

Sources/SwiftOperatorPrecedence/OperatorPrecedence+Defaults.swift

@@ -12,10 +12,10 @@
 import SwiftSyntax
 
 /// Prefabricated operator precedence graphs.
-extension OperatorPrecedence {
+extension OperatorTable {
   /// Operator precedence graph for the logical operators '&&' and '||', for
   /// example as it is used in `#if` processing.
-  public static var logicalOperators: OperatorPrecedence {
+  public static var logicalOperators: OperatorTable {
     let precedenceGroups: [PrecedenceGroup] = [
       PrecedenceGroup(name: "LogicalConjunctionPrecedence",
                       associativity: .left, assignment: false,
@@ -32,7 +32,7 @@ extension OperatorPrecedence {
                precedenceGroup: "LogicalDisjunctionPrecedence")
     ]
 
-    return try! OperatorPrecedence(
+    return try! OperatorTable(
       precedenceGroups: precedenceGroups, operators: operators)
   }
 
@@ -44,7 +44,7 @@ extension OperatorPrecedence {
   /// without requiring access to the standard library source code. However,
   /// because it does not incorporate user-defined operators, it will only
   /// ever be useful for a quick approximation.
-  public static var standardOperators: OperatorPrecedence {
+  public static var standardOperators: OperatorTable {
     let precedenceGroups: [PrecedenceGroup] = [
       PrecedenceGroup(
         name: "AssignmentPrecedence",
@@ -400,7 +400,7 @@ extension OperatorPrecedence {
       )
     ]
 
-    return try! OperatorPrecedence(
+    return try! OperatorTable(
       precedenceGroups: precedenceGroups, operators: operators)
   }
 }

Sources/SwiftOperatorPrecedence/OperatorPrecedence+Folding.swift

@@ -17,7 +17,7 @@ extension ExprSyntax {
     self.is(UnresolvedIsExprSyntax.self) || self.is(UnresolvedAsExprSyntax.self)
   }
 }
-extension OperatorPrecedence {
+extension OperatorTable {
   private struct PrecedenceBound {
     let groupName: PrecedenceGroupName?
     let isStrict: Bool
@@ -395,11 +395,11 @@ extension OperatorPrecedence {
     /// also throw.
     var firstFatalError: OperatorPrecedenceError? = nil
 
-    let opPrecedence: OperatorPrecedence
+    let opPrecedence: OperatorTable
     let errorHandler: OperatorPrecedenceErrorHandler
 
     init(
-      opPrecedence: OperatorPrecedence,
+      opPrecedence: OperatorTable,
       errorHandler: @escaping OperatorPrecedenceErrorHandler
     ) {
       self.opPrecedence = opPrecedence

Sources/SwiftOperatorPrecedence/OperatorPrecedence+Semantics.swift

@@ -82,18 +82,18 @@ extension Operator {
   }
 }
 
-extension OperatorPrecedence {
+extension OperatorTable {
   /// Integrate the operator and precedence group declarations from the given
   /// source file into the operator precedence tables.
   public mutating func addSourceFile(
     _ sourceFile: SourceFileSyntax,
     errorHandler: OperatorPrecedenceErrorHandler = { throw $0 }
   ) rethrows {
     class OperatorAndGroupVisitor : SyntaxAnyVisitor {
-      var opPrecedence: OperatorPrecedence
+      var opPrecedence: OperatorTable
       var errors: [OperatorPrecedenceError] = []
 
-      init(opPrecedence: OperatorPrecedence) {
+      init(opPrecedence: OperatorTable) {
         self.opPrecedence = opPrecedence
         super.init(viewMode: .fixedUp)
       }

Sources/SwiftOperatorPrecedence/OperatorPrecedence.swift renamed to Sources/SwiftOperatorPrecedence/OperatorTable.swift

@@ -11,10 +11,15 @@
 //===----------------------------------------------------------------------===//
 import SwiftSyntax
 
-/// Maintains information about operators and their relative precedence,
-/// providing the core operations for "folding" sequence expression syntax into
-/// a structured expression syntax tree.
-public struct OperatorPrecedence {
+/// Maintains and validates information about all operators in a Swift program.
+///
+/// The operator table keep track of the various operator and precedence group
+/// declarations within a program. Its core operations involve processing the
+/// operator and precedence group declarations from a source tree into a
+/// semantic representation, validating the correctness of those declarations,
+/// and "folding" sequence expression syntax into a structured expression
+/// syntax tree.
+public struct OperatorTable {
   var precedenceGraph: PrecedenceGraph = .init()
   var operators: [OperatorName : Operator] = [:]
 
@@ -60,7 +65,7 @@ public struct OperatorPrecedence {
   }
 }
 
-extension OperatorPrecedence {
+extension OperatorTable {
   /// Look for the precedence group corresponding to the given operator.
   func lookupOperatorPrecedenceGroupName(
     _ operatorName: OperatorName,

Tests/SwiftOperatorPrecedenceTest/OperatorPrecedence.swift renamed to Tests/SwiftOperatorPrecedenceTest/OperatorTable.swift

@@ -48,15 +48,15 @@ class ExplicitParenFolder : SyntaxRewriter {
       return ExprSyntax(node)
     }
 
-    return OperatorPrecedence.makeBinaryOperationExpr(
+    return OperatorTable.makeBinaryOperationExpr(
       lhs: visit(Syntax(leftOperand)).as(ExprSyntax.self)!,
       op: visit(Syntax(middleExpr)).as(ExprSyntax.self)!,
       rhs: visit(Syntax(rightOperand)).as(ExprSyntax.self)!
     )
   }
 }
 
-extension OperatorPrecedence {
+extension OperatorTable {
   /// Assert that parsing and folding the given "unfolded" source code
   /// produces the same syntax tree as the fully-parenthesized version of
   /// the same source.
@@ -90,7 +90,7 @@ extension OperatorPrecedence {
 
 public class OperatorPrecedenceTests: XCTestCase {
   func testLogicalExprsSingle() throws {
-    let opPrecedence = OperatorPrecedence.logicalOperators
+    let opPrecedence = OperatorTable.logicalOperators
     let parsed = try Parser.parse(source: "x && y || w && v || z")
     let sequenceExpr =
       parsed.statements.first!.item.as(SequenceExprSyntax.self)!
@@ -100,13 +100,13 @@ public class OperatorPrecedenceTests: XCTestCase {
   }
 
   func testLogicalExprs() throws {
-    let opPrecedence = OperatorPrecedence.logicalOperators
+    let opPrecedence = OperatorTable.logicalOperators
     try opPrecedence.assertExpectedFold("x && y || w", "((x && y) || w)")
     try opPrecedence.assertExpectedFold("x || y && w", "(x || (y && w))")
   }
 
   func testSwiftExprs() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     let parsed = try Parser.parse(source: "(x + y > 17) && x && y || w && v || z")
     let sequenceExpr =
         parsed.statements.first!.item.as(SequenceExprSyntax.self)!
@@ -116,27 +116,27 @@ public class OperatorPrecedenceTests: XCTestCase {
   }
 
   func testNestedSwiftExprs() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     let parsed = try Parser.parse(source: "(x + y > 17) && x && y || w && v || z")
     let foldedAll = try opPrecedence.foldAll(parsed)
     XCTAssertEqual("\(foldedAll)", "(x + y > 17) && x && y || w && v || z")
     XCTAssertFalse(foldedAll.containsExprSequence)
   }
 
   func testAssignExprs() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     try opPrecedence.assertExpectedFold("a = b + c", "(a = (b + c))")
     try opPrecedence.assertExpectedFold("a = b = c", "(a = (b = c))")
   }
 
   func testCastExprs() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     try opPrecedence.assertExpectedFold("a is (b)", "(a is (b))")
     try opPrecedence.assertExpectedFold("a as c == nil", "((a as c) == nil)")
   }
 
   func testArrowExpr() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     try opPrecedence.assertExpectedFold(
       "a = b -> c -> d",
       "(a = (b -> (c -> d)))"
@@ -165,7 +165,7 @@ public class OperatorPrecedenceTests: XCTestCase {
     """
 
     let parsedOperatorPrecedence = try Parser.parse(source: logicalOperatorSources)
-    var opPrecedence = OperatorPrecedence()
+    var opPrecedence = OperatorTable()
     try opPrecedence.addSourceFile(parsedOperatorPrecedence)
 
     let parsed = try Parser.parse(source: "x && y || w && v || z")
@@ -195,7 +195,7 @@ public class OperatorPrecedenceTests: XCTestCase {
 
     let parsedOperatorPrecedence = try Parser.parse(source: sources)
 
-    var opPrecedence = OperatorPrecedence()
+    var opPrecedence = OperatorTable()
     var errors: [OperatorPrecedenceError] = []
     opPrecedence.addSourceFile(parsedOperatorPrecedence) { error in
       errors.append(error)
@@ -244,7 +244,7 @@ public class OperatorPrecedenceTests: XCTestCase {
       infix operator ++: D
       """)
 
-    var opPrecedence = OperatorPrecedence()
+    var opPrecedence = OperatorTable()
     try opPrecedence.addSourceFile(parsedOperatorPrecedence)
 
     do {
@@ -331,7 +331,7 @@ public class OperatorPrecedenceTests: XCTestCase {
   }
 
   func testTernaryExpr() throws {
-    let opPrecedence = OperatorPrecedence.standardOperators
+    let opPrecedence = OperatorTable.standardOperators
     try opPrecedence.assertExpectedFold(
       "b + c ? y : z ? z2 : z3",
       "((b + c) ? y : (z ? z2 : z3))")