Rename SwiftOperatorPrecedence -> SwiftOperators

This module has been generalized (slightly) to handle everything involving
Swift's user-defined operators and precedence groups, so rename it
accordingly.

Author: DougGregor

Package.swift

@@ -45,8 +45,8 @@ let package = Package(
     .macCatalyst(.v13),
   ],
   products: [
-    .library(name: "SwiftOperatorPrecedence", type: .static,
-             targets: ["SwiftOperatorPrecedence"]),
+    .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"]),
@@ -117,7 +117,7 @@ let package = Package(
       ]
     ),
     .target(
-      name: "SwiftOperatorPrecedence",
+      name: "SwiftOperators",
       dependencies: ["SwiftSyntax", "SwiftParser", "SwiftDiagnostics"]
     ),
     .executableTarget(
@@ -176,8 +176,8 @@ let package = Package(
       dependencies: ["SwiftDiagnostics", "SwiftParser", "_SwiftSyntaxTestSupport"]
     ),
     .testTarget(
-      name: "SwiftOperatorPrecedenceTest",
-      dependencies: ["SwiftOperatorPrecedence", "_SwiftSyntaxTestSupport",
+      name: "SwiftOperatorsTest",
+      dependencies: ["SwiftOperators", "_SwiftSyntaxTestSupport",
                      "SwiftParser"]
     ),
   ]

Sources/SwiftOperatorPrecedence/Operator.swift renamed to Sources/SwiftOperators/Operator.swift

@@ -43,7 +43,7 @@ extension OperatorPrecedenceError : DiagnosticMessage {
   }
 
   public var diagnosticID: MessageID {
-    MessageID(domain: "SwiftOperatorPrecedence", id: "\(self)")
+    MessageID(domain: "SwiftOperators", id: "\(self)")
   }
 }
 

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

@@ -3,11 +3,11 @@
 <plist version="1.0">
 <dict>
 	<key>CFBundleName</key>
-	<string>SwiftOperatorPrecedence</string>
+	<string>SwiftOperators</string>
 	<key>CFBundleDisplayName</key>
-	<string>SwiftOperatorPrecedence</string>
+	<string>SwiftOperators</string>
 	<key>CFBundleIdentifier</key>
-	<string>com.apple.swift-operator-precedence</string>
+	<string>com.apple.swift-operators</string>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>en</string>
 	<key>CFBundleIconFile</key>
@@ -24,7 +24,7 @@
 	<string>0.1.0</string>
 	<key>CDAppleDefaultAvailability</key>
 	<dict>
-		<key>SwiftOperatorPrecedence</key>
+		<key>SwiftOperators</key>
 		<array>
 			<dict>
 				<key>name</key>

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

@@ -1,8 +1,10 @@
-# ``SwiftOperatorPrecedence``
+# ``SwiftOperators``
 
 
 
-An implementation of Swift's operator precedence semantics for Swift syntax trees.
+An implementation of Swift's user-defined operator declarations and precedence 
+groups, allowing a program to reason about the relative precedence of 
+infix operations and transform syntax trees to describe the order of operations.
 
 
 
@@ -15,7 +17,7 @@ infix operator +: AdditionPrecedence
 infix operator *: MultiplicationPrecedence
 ```
 
-The define the associativity and relative precedence of these operators is defined via a [precedence group declaration](https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#grammar_precedence-group-declaration). For example, the precedence groups used for `+` and `*` are defined as follows:
+The associativity and relative precedence of these operators is defined via a [precedence group declaration](https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#grammar_precedence-group-declaration). For example, the precedence groups used for `+` and `*` are defined as follows:
 
 ```swift
 precedencegroup AdditionPrecedence {
@@ -29,18 +31,18 @@ precedencegroup MultiplicationPrecedence {
 
 The Swift parser itself does not reason about the semantics of operators or precedence groups. Instead, an expression such as `x + y * z` will be parsed into a `SequenceExprSyntax` node whose children are `x`, a `BinaryOperatorExprSyntax` node for `+`, `y`, a `BinaryOperatorExprSyntax` node for `*`, and `z`. This is all the structure that is possible to parse for a Swift program without semantic information about operators and precedence groups.
 
-The `SwiftOperatorPrecedence` module interprets operator and precedence group declarations to provide those semantics. Its primary operation is to "fold" a `SequenceExprSyntax` node into an equivalent syntax tree that fully expresses the order of operations: in our example case, this means that the resulting syntax node will be an `InfixOperatorExprSyntax` whose left-hand side is `x` and operator is `+`, and whose right-hand side is another `InfixOperatorExprSyntax` node representing `y * z`. The resulting syntax tree will still accurately represent the original source input, but will be completely describe the order of evaluation and be suitable for structured editing or later semantic passes, such as type checking.
+The `SwiftOperators` module interprets operator and precedence group declarations to provide those semantics. Its primary operation is to "fold" a `SequenceExprSyntax` node into an equivalent syntax tree that fully expresses the order of operations: in our example case, this means that the resulting syntax node will be an `InfixOperatorExprSyntax` whose left-hand side is `x` and operator is `+`, and whose right-hand side is another `InfixOperatorExprSyntax` node representing `y * z`. The resulting syntax tree will still accurately represent the original source input, but will be completely describe the order of evaluation and be suitable for structured editing or later semantic passes, such as type checking.
 
 
 
 ## Quickstart
 
-The `SwiftOperatorPrecedence` library is typically used to take a raw parse of Swift code and apply the operator-precedence transformation to it to replace all `SequenceExprSyntax` nodes with more structured syntax nodes. For example, we can use this library's representation of the Swift standard library operators to provide a structured syntax tree for the expression `x + y * z`:
+The `SwiftOperators` library is typically used to take a raw parse of Swift code and apply the operator-precedence transformation to it to replace all `SequenceExprSyntax` nodes with more structured syntax nodes. For example, we can use this library's representation of the Swift standard library operators to provide a structured syntax tree for the expression `x + y * z`:
 
 ```swift
 import SwiftSyntax
 import SwiftParser
-import SwiftOperatorPrecedence
+import SwiftOperators
 
 var opPrecedence = OperatorTable.standardOperators // Use the Swift standard library operators
 let parsed = try Parser.parse(source: "x + y * z")

Sources/SwiftOperatorPrecedence/OperatorTable+Defaults.swift renamed to Sources/SwiftOperators/OperatorTable+Defaults.swift

@@ -1,7 +1,7 @@
 import XCTest
 import SwiftSyntax
 import SwiftParser
-@_spi(Testing) import SwiftOperatorPrecedence
+@_spi(Testing) import SwiftOperators
 import _SwiftSyntaxTestSupport
 
 /// Visitor that looks for ExprSequenceSyntax nodes.