Stabilize WebAssembly multivalue and reference-types target features

This commit is similar to rust-lang#117457 in that it's stabilizing target
features specific to WebAssembly targets. The previous PR left out these
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.

A test has been added here not only for these two 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

Author: alexcrichton

compiler/rustc_target/src/target_features.rs

@@ -414,10 +414,10 @@ 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, &[]),

tests/ui/wasm/wasm-stable-target-features.rs

@@ -0,0 +1,45 @@
+//@ 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() {}
+
+fn main() {
+    foo1();
+    foo2();
+    foo3();
+    foo4();
+    foo5();
+    foo6();
+    foo7();
+    foo8();
+    foo9();
+}