[Merged by Bors] - Fix PipeSystem panicking with exclusive systems

[inodentry]

Without this fix, piped systems containing exclusive systems fail to run, giving a runtime panic.
With this PR, running piped systems that contain exclusive systems now works.

Explanation of the bug

This is because, unless overridden, the default implementation of run from the System trait simply calls run_unsafe. That is not valid for exclusive systems. They must always be called via run, as run_unsafe takes &World instead of &mut World.

Trivial reproduction example:

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_system(exclusive.pipe(another))
        .run();
}

fn exclusive(_world: &mut World) {}
fn another() {}

If you run this, you will get a panic 'Cannot run exclusive systems with a shared World reference' and the backtrace shows how bevy (correctly) tries to call the run method (because the system is exclusive), but it is the implementation from the System trait (because PipeSystem does not have its own), which calls run_unsafe (incorrect):

• 3: <bevy_ecs::system::system_piping::PipeSystem<SystemA,SystemB> as bevy_ecs::system::system::System>::run_unsafe
• 4: bevy_ecs::system::system::System::run

[NiklasEi]

Sorry if this is a dumb question, but does run taking &mut World mean, that now all piped systems are essentially exclusive and will not be parallelized?

[inodentry]

No.

There is the is_exclusive method, whose responsibility is to report to bevy whether the system is exclusive or not. For PipedSystem, it returns true if any of the member systems are exclusive. If none are, it will return false.

That tells bevy how to set up the system descriptors and where to place the system in the schedule.

This PR has no effect on that. It simply makes sure that PipeSystem will behave correctly if it happens to be exclusive.

Exclusive systems and parallel systems are ran in different ways.

Exclusive systems (and parallel systems that the user wants to treat as exclusive, via .at_end() or whatever) will run one-by-one at the designated part of the stage, and they will be called via the run method (giving them &mut World access).

Regular parallel systems will typically be run by the parallel system executor algorithm in the middle of the stage. It will verify the invariants (ensure safe non-overlapping data access) for the system and call it via run_unsafe when it is safe to do so. This method is intended for shared World access, when other systems may be running in parallel, but the safety is the responsibility of the caller.

Regular parallel systems can be called via either run or run_unsafe. The default impl for run in the trait System will simply call run_unsafe (this is always safe, since run has &mut World exclusive access). But run_unsafe will panic if the system is exclusive (hence this PR), because one cannot turn the & back into &mut.

[hymm]

Won't block on this, but can you add a test to prevent regressions in the future?

[alice-i-cecile]

bors r+

[bors]

Pull request successfully merged into main.

Build succeeded:

• build-and-install-on-iOS
• build-android
• build (macos-latest)
• build (ubuntu-latest)
• build-wasm
• build (windows-latest)
• build-without-default-features (bevy)
• build-without-default-features (bevy_ecs)
• build-without-default-features (bevy_reflect)
• check-compiles
• check-doc
• check-missing-examples-in-docs
• ci
• markdownlint
• run-examples
• run-examples-on-wasm
• run-examples-on-windows-dx12