removeAll method is triggering an observation change even though array is unchanged

@Observable classes are observed based on accessor calls, not direct equality comparisons.

The key point here is that calling removeAll, a mutating method, calls the modify accessor, which is implemented to unconditionally notify observers regardless of equality. If it had called the setter instead, an additional equality check would be performed and observers will not be notified if the new and old values are equal.

@Observable
class Foo {
    var x = 0
}
extension Int {
    // a mutating func that does nothing!
    mutating func g() {}
}
struct ContentView: View {
    @State var f = Foo()
    var body: some View {
        let  = Self.printChanges()
        Text("\(f.x)")
        Button("f.x.g()") {
            // this ends up calling the modify accessor
            // and causes a view update
            f.x.g()
        }
        Button("f.x = 0") {
            // this ends up calling the setter
            // and does not cause a view update
            f.x = 0
        }
    }
}

Let's expand the @Observable on Foo:

This expands to:

class Foo {
    var x: Int
    var x: Int = 0 {
        @storageRestrictions(initializes: x)
        init(initialValue) {
            x = initialValue
        }
        get {
            access(keyPath: \.x)
            return x
        }
        set {
            guard shouldNotifyObservers(x, newValue) else {
                x = newValue
                return
            }
            withMutation(keyPath: \.x) {
                x = newValue
            }
        }
        modify {
            access(keyPath: \.x)
            $observationRegistrar.willSet(self, keyPath: \.x)
            defer {
                $observationRegistrar.didSet(self, keyPath: \.x)
            }
            yield &x
        }
    }
    @ObservationIgnored private let $observationRegistrar = Observation.ObservationRegistrar()
    internal nonisolated func access(
        keyPath: KeyPath
    ) {
        $observationRegistrar.access(self, keyPath: keyPath)
    }
    internal nonisolated func withMutation(
        keyPath: KeyPath,
         mutation: () throws -> U
    ) rethrows -> U {
        try $observationRegistrar.withMutation(of: self, keyPath: keyPath, mutation)
    }
    private nonisolated func shouldNotifyObservers( lhs: U,  rhs: U) -> Bool {
        true
    }
    private nonisolated func shouldNotifyObservers( lhs: U,  rhs: U) -> Bool {
        lhs != rhs
    }
    private nonisolated func shouldNotifyObservers( lhs: U,  rhs: U) -> Bool {
        lhs !== rhs
    }
    private nonisolated func shouldNotifyObservers( lhs: U,  rhs: U) -> Bool {
        lhs != rhs
    }
}

Notice that the setter of x first checks shouldNotifyObservers, but there is no such check in the modify accessor.

Why is there a modify accessor in the first place and how is it different from the setter?

The purpose of the modify accessor is to reduce creating copies when modifying properties in ways that can be done "in place", e.g. calling a mutating function.

Consider what happens if x has only a setter, in which case f.x.g() will call this setter instead of modify. In order to call this setter, a copy of x needs to be created, so that it can be passed to the newValue parameter of the setter. To illustrate with pseudocode,

var copy = f.x
copy.g()
f.setX(newValue: copy)

If x is very large struct but g only modifies a very small part of x, this copy is wasteful. The modify accessor allows this to be done in place. See the line yield &x in the modify accessor above. This line is what invokes g, effectively doing x.g(), without creating a copy.

Now you should see why there is no shouldNotifyObservers check in the modify accessor. To do this check, you must have the new value and old value at the same time, but the whole point of the modify accessor is to do the change in place. You cannot know what the new value will be, before modifying x to become that new value. You could store the old value in a local variable like this, but then you cannot call willSet before it is actually set:

modify {
    access(keyPath: \.x)
    // this creates a copy, defeating the very purpose of a modify accessor!
    let oldValue = x
    yield &x
    if shouldNotifyObservers(oldValue, x) {
        // willSet is called *after* x is changed ???
        $observationRegistrar.willSet(self, keyPath: \.x)
        $observationRegistrar.didSet(self, keyPath: \.x)
    }
}

Finally, I should mention that @Observable didn't use to generate _modify accessors, as far as I remember. This is new behaviour in Xcode 26. I think it used to only generate getters and setters, and without the shouldNotifyObservers check. The macro might change its behaviour in the future too.