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:

#[rustc_intrinsic]
unsafe fn unreachable() -> !;

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

• 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. (Implemented in Change intrinsic declarations to new style #132907, changes old intrinsic declaration to new declaration #133106, ports last few library files to new intrinsic style #136005)
• Port the uses of extern "rust-intrinsic" in src/tools/miri and tests/ui/simd to the new style.
  This is implemented in Partial progress on #132735: Replace extern "rust-intrinsic" with #[rustc_intrinsic] across the codebase #135333, Port ui/simd tests to use the intrinsic macro #136022.
• Similarly port the extern "rust-intrinsic" in this file (note that this is a separate repository)
• Remove support for extern "rust-intrinsic" blocks from the compiler -- in particular, remove this. A bunch of tests will still 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.
• Determine whether there is more cleanup that can be done. For instance, this can be removed. Maybe we can get rid of Abi::RustIntrinsic entirely?

[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