test fallback implementations on all targets

Resolve the real `miri` executable for the active toolchain.

Test for <https://github.com/rust-lang/rust/issues/135315>.

Test for <https://github.com/rust-lang/rust/issues/135316>.

Rename a file if from and to are in the same filesystem or copy and remove the file otherwise

Checks that an access through a wildcard reference doesn't disable any exposed references. It tests this with exposed references where one is the ance

Checks that an access through a wildcard reference doesn't disable any exposed references. It tests this with exposed references that are siblings of

Checks that accessing through a reborrowed wildcard doesn't disable any exposed reference.

Checks that wildcard accesses do not invalidate any exposed nodes through which the access could have happened. It checks this for the case where some

The test taken from the Rust documentation.

Transmuting &&i32 to &&mut i32 is fine.

Ensure that if we derive from a mut a raw, and then from that a mut, and then read through the original mut, that does not invalidate the raw. This sh

A variant of `mut_raw_mut` that does *not* get accepted by Tree Borrows. It's kind of an accident that we accept it in Stacked Borrows...

Escape a mut to raw, then share the same mut and use the share, then the raw. That should work.

Create first a shared reference and then a raw pointer from a `&mut` should permit mutation through that raw pointer.

Regression test from <https://github.com/rust-lang/rust/issues/117288>.

Climb the tree to get the tag of a distant ancestor. Allows operations on tags that are unreachable by the program but still exist in the tree. Not gu

Determines how many times a `--flag` is present.

When accessing an allocation through a tag that was created from wildcard reference we treat nodes with a larger tag as if the access could only have

This hits a corner case in the logic for clearing padding on typed copies.

Patches both section counters and promotes their tracking allocas.

Performs a normal access on the tree containing `access_source`. Returns the root index of this tree. `access_source`: The index of the tag being acc

Performs a wildcard access on the tree with root `root`. Takes the `access_relatedness` for each node from the `WildcardState` datastructure. `root`:

Print extra text if the tag is exposed.

Print the permission with the format ` Res`/` Re*`/` Unq`/` Frz`/` Dis` for accessed locations and `?Res`/`?Re*`/`?Unq`/`?Frz`/`?Dis` for unaccessed l

Print extra text if the tag has a protector.

Print the tag with the format `<XYZ>` if the tag is unnamed, and `<XYZ=name>` if the tag is named.

Display the contents of the tree.

Print the diff between me and an older tree

Determines if this transition would disable the permission.

If a reference is protected, then all foreign writes to it cause UB. This effectively means any write needs to happen through a child of the protected

Checks that we can pass a wildcard reference to a function.

Checks whether we correctly handle the protector being released on a conflicted exposed reference.

What kind of access to perform before releasing the protector.