From 1ee87c9b8a933f49cdf12a49acaac5b28c1ca9cb Mon Sep 17 00:00:00 2001
From: Alex Crichton <alex@alexcrichton.com>
Date: Mon, 30 Sep 2024 17:51:06 -0700
Subject: [PATCH] Stabilize WebAssembly `multivalue`, `reference-types`, and
 `tail-call` target features

For the `multivalue` and `reference-types` features this commit is
similar to #117457 in that it's stabilizing target features specific to
WebAssembly targets. The previous PR left out these two features because
they weren't expected to change much about compiled code so it was
unclear what the rationale was. It has [since been discovered][blog]
that `reference-types` can be useful as it changes the binary format of
the `call_indirect` instruction. Additionally [on Zulip][zulip] there's
a use case of detecting these features at compile time and generating a
compile error to better warn users about features not supported on
engines.

This PR then additionally adds the `tail-call` feature which corresponds
to the [tail-call] proposal to WebAssembly. This feature advanced to
"phase 4" in the WebAssembly CG awhile back and has been supported in
LLVM for quite some time now. Engines are finishing up implementations
or have already shipped implementations, so while this is a bit of a
late addition to Rust itself it reflects the current status of
WebAssembly's state of the feature.

A test has been added here not only for these features but other
WebAssembly features as well to showcase that they're usable without
feature gates in stable Rust.

[blog]: https://blog.rust-lang.org/2024/09/24/webassembly-targets-change-in-default-target-features.html
[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general/topic/wasm32.20reference-types.20.2F.20multivalue.20in.201.2E82-beta.20not.20enabled/near/473893987
[tail-call]: https://github.com/webassembly/tail-call
---
 compiler/rustc_target/src/target_features.rs |  5 +-
 tests/ui/wasm/wasm-stable-target-features.rs | 49 ++++++++++++++++++++
 2 files changed, 52 insertions(+), 2 deletions(-)
 create mode 100644 tests/ui/wasm/wasm-stable-target-features.rs

diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index be14107baa97e..863cde80b196e 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -414,13 +414,14 @@ const WASM_ALLOWED_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("bulk-memory", Stable, &[]),
     ("exception-handling", Unstable(sym::wasm_target_feature), &[]),
     ("extended-const", Stable, &[]),
-    ("multivalue", Unstable(sym::wasm_target_feature), &[]),
+    ("multivalue", Stable, &[]),
     ("mutable-globals", Stable, &[]),
     ("nontrapping-fptoint", Stable, &[]),
-    ("reference-types", Unstable(sym::wasm_target_feature), &[]),
+    ("reference-types", Stable, &[]),
     ("relaxed-simd", Stable, &["simd128"]),
     ("sign-ext", Stable, &[]),
     ("simd128", Stable, &[]),
+    ("tail-call", Stable, &[]),
     // tidy-alphabetical-end
 ];
 
diff --git a/tests/ui/wasm/wasm-stable-target-features.rs b/tests/ui/wasm/wasm-stable-target-features.rs
new file mode 100644
index 0000000000000..b6d4b67d0703f
--- /dev/null
+++ b/tests/ui/wasm/wasm-stable-target-features.rs
@@ -0,0 +1,49 @@
+//@ only-wasm32
+//@ build-pass
+
+// Test that a variety of WebAssembly features are all stable and can be used in
+// `#[target_feature]`. That should mean they're also available via
+// `#[cfg(target_feature)]` as well.
+
+#[target_feature(enable = "multivalue")]
+fn foo1() {}
+
+#[target_feature(enable = "reference-types")]
+fn foo2() {}
+
+#[target_feature(enable = "bulk-memory")]
+fn foo3() {}
+
+#[target_feature(enable = "extended-const")]
+fn foo4() {}
+
+#[target_feature(enable = "mutable-globals")]
+fn foo5() {}
+
+#[target_feature(enable = "nontrapping-fptoint")]
+fn foo6() {}
+
+#[target_feature(enable = "simd128")]
+fn foo7() {}
+
+#[target_feature(enable = "relaxed-simd")]
+fn foo8() {}
+
+#[target_feature(enable = "sign-ext")]
+fn foo9() {}
+
+#[target_feature(enable = "tail-call")]
+fn foo10() {}
+
+fn main() {
+    foo1();
+    foo2();
+    foo3();
+    foo4();
+    foo5();
+    foo6();
+    foo7();
+    foo8();
+    foo9();
+    foo10();
+}