Remove transformTargetToCurrent, improvements to RangeTarget

.swiftpm/xcode/xcshareddata/xcschemes/Neon.xcscheme

@@ -87,6 +87,16 @@
                ReferencedContainer = "container:">
             </BuildableReference>
          </TestableReference>
+         <TestableReference
+            skipped = "NO">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "RangeStateTests"
+               BuildableName = "RangeStateTests"
+               BlueprintName = "RangeStateTests"
+               ReferencedContainer = "container:">
+            </BuildableReference>
+         </TestableReference>
       </Testables>
    </TestAction>
    <LaunchAction

Package.resolved

@@ -5,8 +5,7 @@
       "kind" : "remoteSourceControl",
       "location" : "https://github.com/ChimeHQ/Rearrange",
       "state" : {
-        "revision" : "0fb658e721c68495f6340c211cc6d4719e6b52d8",
-        "version" : "1.6.0"
+        "revision" : "3b154b59176ce40839071e7830c83410a0139d86"
       }
     },
     {

Package.swift

@@ -10,11 +10,12 @@ let package = Package(
 	],
 	dependencies: [
 		.package(url: "https://github.com/ChimeHQ/SwiftTreeSitter", revision: "87ed52a71d4ad6b5e6a11185b42f6f74eb5b47da"),
-		.package(url: "https://github.com/ChimeHQ/Rearrange", from: "1.6.0"),
+		.package(url: "https://github.com/ChimeHQ/Rearrange", revision: "3b154b59176ce40839071e7830c83410a0139d86"),
 	],
 	targets: [
         .target(name: "ConcurrencyCompatibility"),
 		.target(name: "RangeState", dependencies: ["ConcurrencyCompatibility", "Rearrange"]),
+		.testTarget(name: "RangeStateTests", dependencies: ["RangeState"]),
 		.target(
 			name: "Neon",
 			dependencies: [

Sources/RangeState/RangeProcessor.swift

@@ -156,6 +156,9 @@ extension RangeProcessor {
         }
     }
 
+	/// Array of any mutations that are scheduled to be applied.
+	///
+	/// You can use this property to transform Range, IndexSet, and RangeTarget values to match the current content.
 	public var pendingMutations: [RangeMutation] {
 		pendingEvents.compactMap {
 			switch $0 {
@@ -221,29 +224,6 @@ extension RangeProcessor {
 		completeContentChanged(mutation)
 	}
 
-	public func transformTargetToCurrent(_ target: RangeTarget) -> RangeTarget {
-		switch target {
-		case .all:
-			return .all
-		case var .range(range):
-			for mutation in pendingMutations {
-				guard let newRange = mutation.transform(range: range) else {
-					return .empty
-				}
-
-				range = newRange
-			}
-
-			return .range(range)
-		case var .set(set):
-			for mutation in pendingMutations {
-				set = mutation.transform(set: set)
-			}
-
-			return .set(set)
-		}
-	}
-
 	public func continueFillingIfNeeded() {
 		if hasPendingChanges {
 			return

Sources/RangeState/RangeTarget.swift

@@ -1,12 +1,26 @@
 import Foundation
 
+import Rearrange
+
 public enum RangeTarget: Hashable, Sendable {
 	case set(IndexSet)
 	case range(NSRange)
 	case all
 
 	public static let empty = RangeTarget.set(IndexSet())
 
+	public init(_ set: IndexSet) {
+		self = .set(set)
+	}
+
+	public init(_ range: NSRange) {
+		self = .range(range)
+	}
+
+	public init(_ ranges: [NSRange]) {
+		self = .set(IndexSet(ranges: ranges))
+	}
+
 	public func indexSet(with length: Int) -> IndexSet {
 		let set: IndexSet
 
@@ -21,30 +35,49 @@ public enum RangeTarget: Hashable, Sendable {
 
 		return set
 	}
+}
 
+extension RangeTarget {
 	public func union(_ other: RangeTarget) -> RangeTarget {
 		switch (self, other) {
-		case let (.set(lhs), .set(rhs)):
-			return RangeTarget.set(lhs.union(rhs))
+		case (.set(var set), .set(let rhs)):
+			set.formUnion(rhs)
+			return RangeTarget(set)
 		case (.all, _):
 			return RangeTarget.all
 		case (_, .all):
 			return RangeTarget.all
-		case let (.set(lhs), .range(rhs)):
-			let set = lhs.union(IndexSet(integersIn: rhs))
+		case (.set(var set), .range(let range)):
+			set.insert(range: range)
 
-			return RangeTarget.set(set)
+			return RangeTarget(set)
 		case let (.range(lhs), .set(rhs)):
 			let set = rhs.union(IndexSet(integersIn: lhs))
 
-			return RangeTarget.set(set)
+			return RangeTarget(set)
 		case let (.range(lhs), .range(rhs)):
-			var set = IndexSet()
+			return RangeTarget([lhs, rhs])
+		}
+	}
+
+	public func apply(mutations: [RangeMutation]) -> RangeTarget {
+		switch self {
+		case .all:
+			return .all
+		case var .range(range):
+			for mutation in mutations {
+				guard let newRange = range.apply(mutation) else {
+					return .empty
+				}
+
+				range = newRange
+			}
 
-			set.insert(range: lhs)
-			set.insert(range: rhs)
+			return .range(range)
+		case var .set(set):
+			set.applying(mutations)
 
-			return RangeTarget.set(set)
+			return .set(set)
 		}
 	}
 }

Sources/TreeSitterClient/TreeSitterClient.swift

@@ -142,13 +142,12 @@ extension TreeSitterClient {
 	}
 
 	private func handleInvalidation(_ set: IndexSet, sublayers: Bool) {
-		let target = rangeProcessor.transformTargetToCurrent(.set(set))
-		let transformedSet = target.indexSet(with: configuration.lengthProvider())
+		let transformedSet = set.apply(rangeProcessor.pendingMutations)
 
 		configuration.invalidationHandler(transformedSet)
 
 		if sublayers {
-			sublayerValidator.invalidate(target)
+			sublayerValidator.invalidate(.set(transformedSet))
 		}
 	}
 

Tests/RangeStateTests/RangeTargetTests.swift

@@ -0,0 +1,19 @@
+import XCTest
+
+import RangeState
+
+final class RangeTargetTests: XCTestCase {
+	func testUnion() {
+		let range = RangeTarget(NSRange(0..<10))
+		let set = RangeTarget(IndexSet(integersIn: 10..<20))
+
+		XCTAssertEqual(RangeTarget.all.union(.all), .all)
+		XCTAssertEqual(RangeTarget.all.union(range), .all)
+		XCTAssertEqual(RangeTarget.all.union(set), .all)
+		XCTAssertEqual(range.union(.all), .all)
+		XCTAssertEqual(set.union(.all), .all)
+
+		XCTAssertEqual(range.union(set), .set(IndexSet(integersIn: 0..<20)))
+		XCTAssertEqual(set.union(range), .set(IndexSet(integersIn: 0..<20)))
+	}
+}