Remove support for `extern "rust-intrinsic"` blocks

[RalfJung]

We currently have two ways to declare symbols that are invoked as intrinsics. The old way:

extern "rust-intrinsic" {
    fn unreachable() -> !;
}

The new way, which supports giving a "fallback body" that will be used for backends that do not have the intrinsic implemented:

#[rustc_intrinsic]
#[rustc_intrinsic_must_be_overridden]
unsafe fn unreachable() -> ! { unreachable!() }

The goal of this issue is to remove support for the old style, and consistently use the new style.

1. Port the remaining extern "rust-intrinsic" intrinsics in library to the new style, updating them using the pattern described above. This can be a PR on its own.
2. Port the uses of extern "rust-intrinsic" in src/tools/miri and tests/ui/simd to the new style. In fact, these can use the even newer style (which can't be used in library yet because of bootstraping):

#[rustc_intrinsic]
unsafe fn unreachable();

3. Remove support for extern "rust-intrinsic" blocks from the compiler -- in particular, remove this. AFAIK these are also the only extern blocks that support generics, so there might be more things that can be cleaned up here. (@compiler-errors or @oli-obk might know more about that.) A lot of tests will need updating; you can grep for rust-intrinsic to find them all. They should all be ported to the new style, similar to the PR in step 2.

[compiler-errors]

I do wonder if there's some way we could have body-less free function items when users write #[rustc_intrinsic_must_be_overridden]. Having all these dummy bodies like loop {} and unreachable {} seem kinda meh.

[RalfJung]

Yeah that would be nice. But I guess the parser will reject body-less fn items (with ";" instead of a block) pretty early?

[compiler-errors]

We actually reject them after expansion but before ast lowering.

We could perhaps intercept these bodyless functions during ast lowering and fill them with a dummy body like loop {} or something that diverges rather than having it be manually written on each function.

[compiler-errors]

Obviously only intercepting them if they're marked with rustc_intrinsic_must_be_overridden; if it's a regular function we'd issue the regular error for a bodyless free function, and if it's rustc_intrinsic we could tell the user that it needs to be marked with rustc_intrinsic_must_be_overridden.

[RalfJung]

That's way beyond my knowledge of those parts of the compiler. ;) So sure, sounds great. :D

Cc @petrochenkov

Obviously only intercepting them if they're marked with rustc_intrinsic_must_be_overridden

I was actually going to suggest that a #[rustc_intrinsic] not having a body should replace the rustc_intrinsic_must_be_overridden attribute.

[compiler-errors]

Oh, that works too.

[workingjubilee]

hmm do we have the notion of a builtin attribute macro...?

[compiler-errors]

@workingjubilee: Yes