Why does transformation passes in Affine dialect inspect its sibling dialects?

From the “Pass infrastructure” documentation (Pass Infrastructure - MLIR)
It states passes must not inspect the state of sibling operations since other threads might be modifying it.
However, affine transformation passes inspects its sibling operations to find optimization opportunities (such as building memory dependence graph with store and load operations).

Question is,
How is this possible without violating the above rule?
(I looked into the code, but it seems it walks through sibling operations and inspects them)

I suspect that since none of the operations inside the function in affine dialect is marked ‘IsolatedFromAbove’, so pass manager does not run separate pass on them, which means we don’t have to worry about another thread modifying its state simultaneously.

Am I getting it right? If not, what am I missing here?

When affine passes are scheduled, it will be for example on each “function” operation separately. The pass itself then look into the body of a function and can do anything in this scope. What is can’t do is look into other functions (the solution for this would be to schedule the pass at one level above, e.g. the module).

Thank you. So, I guess what ‘sibling’ operations in the above document means is another kind of operations that pass can run on ('not load, store, add operations which doesn’t have a separate pass).