Add feature gates for f16 and f128

tgross35 · tgross35 · commit 82baffa7f1b7 · 2024-03-03T23:12:38.000-05:00
Includes related tests and documentation pages.
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -1,7 +1,7 @@
 use rustc_ast as ast;
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{attr, AssocConstraint, AssocConstraintKind, NodeId};
-use rustc_ast::{PatKind, RangeEnd};
+use rustc_ast::{token, PatKind, RangeEnd};
 use rustc_feature::{AttributeGate, BuiltinAttribute, Features, GateIssue, BUILTIN_ATTRIBUTE_MAP};
 use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
 use rustc_session::Session;
@@ -383,6 +383,17 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
             ast::ExprKind::TryBlock(_) => {
                 gate!(&self, try_blocks, e.span, "`try` expression is experimental");
             }
+            ast::ExprKind::Lit(token::Lit { kind: token::LitKind::Float, suffix, .. }) => {
+                match suffix {
+                    Some(sym::f16) => {
+                        gate!(&self, f16, e.span, "the feature `f16` is unstable")
+                    }
+                    Some(sym::f128) => {
+                        gate!(&self, f128, e.span, "the feature `f128` is unstable")
+                    }
+                    _ => (),
+                }
+            }
             _ => {}
         }
         visit::walk_expr(self, e)
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
@@ -461,6 +461,10 @@ declare_features! (
     (unstable, extended_varargs_abi_support, "1.65.0", Some(100189)),
     /// Allows defining `extern type`s.
     (unstable, extern_types, "1.23.0", Some(43467)),
+    /// Allow using 128-bit (quad precision) floating point numbers.
+    (unstable, f128, "CURRENT_RUSTC_VERSION", Some(116909)),
+    /// Allow using 16-bit (half precision) floating point numbers.
+    (unstable, f16, "CURRENT_RUSTC_VERSION", Some(116909)),
     /// Allows the use of `#[ffi_const]` on foreign functions.
     (unstable, ffi_const, "1.45.0", Some(58328)),
     /// Allows the use of `#[ffi_pure]` on foreign functions.
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -5,8 +5,10 @@ use rustc_middle::bug;
 use rustc_middle::ty;
 use rustc_session::lint::builtin::PROC_MACRO_DERIVE_RESOLUTION_FALLBACK;
 use rustc_session::lint::BuiltinLintDiagnostics;
+use rustc_session::parse::feature_err;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::{ExpnId, ExpnKind, LocalExpnId, MacroKind, SyntaxContext};
+use rustc_span::sym;
 use rustc_span::symbol::{kw, Ident};
 use rustc_span::Span;
 
@@ -421,6 +423,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         // to detect potential ambiguities.
         let mut innermost_result: Option<(NameBinding<'_>, Flags)> = None;
         let mut determinacy = Determinacy::Determined;
+        let sess = self.tcx.sess;
+        let feat_f16 = self.tcx.features().f16;
+        let feat_f128 = self.tcx.features().f128;
 
         // Go through all the scopes and try to resolve the name.
         let break_result = self.visit_scopes(
@@ -598,7 +603,34 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
                         result
                     }
                     Scope::BuiltinTypes => match this.builtin_types_bindings.get(&ident.name) {
-                        Some(binding) => Ok((*binding, Flags::empty())),
+                        Some(binding) => {
+                            match ident.name {
+                                sym::f16 => {
+                                    if !feat_f16 && !ident.span.allows_unstable(sym::f16) {
+                                        feature_err(
+                                            sess,
+                                            sym::f16,
+                                            ident.span,
+                                            "the feature `f16` is unstable",
+                                        )
+                                        .emit();
+                                    }
+                                }
+                                sym::f128 => {
+                                    if !feat_f128 && !ident.span.allows_unstable(sym::f128) {
+                                        feature_err(
+                                            sess,
+                                            sym::f128,
+                                            ident.span,
+                                            "the feature `f128` is unstable",
+                                        )
+                                        .emit();
+                                    }
+                                }
+                                _ => (),
+                            }
+                            Ok((*binding, Flags::empty()))
+                        }
                         None => Err(Determinacy::Determined),
                     },
                 };
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -27,6 +27,7 @@ use rustc_middle::middle::resolve_bound_vars::Set1;
 use rustc_middle::{bug, span_bug};
 use rustc_session::config::{CrateType, ResolveDocLinks};
 use rustc_session::lint;
+use rustc_session::parse::feature_err;
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{BytePos, Span, SyntaxContext};
@@ -3923,7 +3924,10 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
                     self.r.trait_map.insert(node_id, traits);
                 }
 
-                if PrimTy::from_name(path[0].ident.name).is_some() {
+                if let Some(prim) = PrimTy::from_name(path[0].ident.name) {
+                    println!("checking path at defer {path:?}");
+                    self.check_prim_gate(prim, path_span);
+
                     let mut std_path = Vec::with_capacity(1 + path.len());
 
                     std_path.push(Segment::from_ident(Ident::with_dummy_span(sym::std)));
@@ -4123,6 +4127,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
                     && PrimTy::from_name(path[0].ident.name).is_some() =>
             {
                 let prim = PrimTy::from_name(path[0].ident.name).unwrap();
+                println!("checking path at module, {:?}", path);
+                self.check_prim_gate(prim, path[0].ident.span);
                 PartialRes::with_unresolved_segments(Res::PrimTy(prim), path.len() - 1)
             }
             PathResult::Module(ModuleOrUniformRoot::Module(module)) => {
@@ -4659,6 +4665,29 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
             self.r.doc_link_traits_in_scope = doc_link_traits_in_scope;
         }
     }
+
+    /// If a primitive requires a feature, emit a diagnostic if that feature is not
+    /// enabled.
+    ///
+    /// This recreates the logic of `gate!` without a visitor's methods.
+    fn check_prim_gate(&self, prim_ty: PrimTy, span: Span) {
+        let PrimTy::Float(float_ty) = prim_ty else {
+            return;
+        };
+
+        let tcx = self.r.tcx();
+        let (sym, msg) = match float_ty {
+            FloatTy::F16 if !tcx.features().f16 => (sym::f16, "the feature `f16` is unstable"),
+            FloatTy::F128 if !tcx.features().f128 => (sym::f128, "the feature `f128` is unstable"),
+            _ => return,
+        };
+
+        if span.allows_unstable(sym) {
+            return;
+        }
+
+        feature_err(tcx.sess, sym, span, msg).emit();
+    }
 }
 
 /// Walks the whole crate in DFS order, visiting each item, counting the declared number of
diff --git a/src/doc/unstable-book/src/language-features/f128.md b/src/doc/unstable-book/src/language-features/f128.md
@@ -0,0 +1,9 @@
+# `f128`
+
+The tracking issue for this feature is: [#116909]
+
+[#116909]: https://github.com/rust-lang/rust/issues/116909
+
+---
+
+Enable the `f128` type for  IEEE 128-bit floating numbers (quad precision).
diff --git a/src/doc/unstable-book/src/language-features/f16.md b/src/doc/unstable-book/src/language-features/f16.md
@@ -0,0 +1,9 @@
+# `f16`
+
+The tracking issue for this feature is: [#116909]
+
+[#116909]: https://github.com/rust-lang/rust/issues/116909
+
+---
+
+Enable the `f16` type for  IEEE 16-bit floating numbers (half precision).
diff --git a/tests/ui/feature-gates/feature-gate-f128.rs b/tests/ui/feature-gates/feature-gate-f128.rs
@@ -0,0 +1,36 @@
+#![allow(unused)]
+
+// ensure gating for primitive use
+mod m1 {
+    const A: f128 = 10.0; //~ ERROR the feature `f128` is unstable
+
+    pub fn main() {
+        let a: f128 = 100.0; //~ ERROR the feature `f128` is unstable
+        let b = 0.0f128; //~ ERROR the feature `f128` is unstable
+        foo(1.23);
+    }
+
+    fn foo(a: f128) {} //~ ERROR the feature `f128` is unstable
+
+    struct Bar {
+        a: f128, //~ ERROR the feature `f128` is unstable
+    }
+}
+
+// ensure we don't restrict name as an identifier or custom types
+mod m2 {
+    #[allow(non_camel_case_types)]
+    struct f128 {
+        a: i32,
+    }
+
+    fn foo() {
+        let f128 = ();
+    }
+
+    fn bar(a: f128) -> i32 {
+        a.a
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-f128.stderr b/tests/ui/feature-gates/feature-gate-f128.stderr
@@ -0,0 +1,53 @@
+error[E0658]: the feature `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:5:14
+   |
+LL |     const A: f128 = 10.0;
+   |              ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:8:16
+   |
+LL |         let a: f128 = 100.0;
+   |                ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:13:15
+   |
+LL |     fn foo(a: f128) {}
+   |               ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:16:12
+   |
+LL |         a: f128,
+   |            ^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f128` is unstable
+  --> $DIR/feature-gate-f128.rs:9:17
+   |
+LL |         let b = 0.0f128;
+   |                 ^^^^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f128)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/feature-gates/feature-gate-f16.rs b/tests/ui/feature-gates/feature-gate-f16.rs
@@ -0,0 +1,36 @@
+#![allow(unused)]
+
+// ensure gating for primitive use
+mod m1 {
+    const A: f16 = 10.0; //~ ERROR the feature `f16` is unstable
+
+    pub fn main() {
+        let a: f16 = 100.0; //~ ERROR the feature `f16` is unstable
+        let b = 0.0f16; //~ ERROR the feature `f16` is unstable
+        foo(1.23);
+    }
+
+    fn foo(a: f16) {} //~ ERROR the feature `f16` is unstable
+
+    struct Bar {
+        a: f16, //~ ERROR the feature `f16` is unstable
+    }
+}
+
+// ensure we don't restrict name as an identifier or custom types
+mod m2 {
+    #[allow(non_camel_case_types)]
+    struct f16 {
+        a: i32,
+    }
+
+    fn foo() {
+        let f16 = ();
+    }
+
+    fn bar(a: f16) -> i32 {
+        a.a
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-f16.stderr b/tests/ui/feature-gates/feature-gate-f16.stderr
@@ -0,0 +1,53 @@
+error[E0658]: the feature `f16` is unstable
+  --> $DIR/feature-gate-f16.rs:5:14
+   |
+LL |     const A: f16 = 10.0;
+   |              ^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f16)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f16` is unstable
+  --> $DIR/feature-gate-f16.rs:8:16
+   |
+LL |         let a: f16 = 100.0;
+   |                ^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f16)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f16` is unstable
+  --> $DIR/feature-gate-f16.rs:13:15
+   |
+LL |     fn foo(a: f16) {}
+   |               ^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f16)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f16` is unstable
+  --> $DIR/feature-gate-f16.rs:16:12
+   |
+LL |         a: f16,
+   |            ^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f16)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0658]: the feature `f16` is unstable
+  --> $DIR/feature-gate-f16.rs:9:17
+   |
+LL |         let b = 0.0f16;
+   |                 ^^^^^^
+   |
+   = note: see issue #116909 <https://github.com/rust-lang/rust/issues/116909> for more information
+   = help: add `#![feature(f16)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
