Feature gate the 128 bit types

Dangling a carrot in front of a donkey.

Author: nagisa

src/libcore/lib.rs

@@ -91,6 +91,7 @@
 #![feature(unboxed_closures)]
 #![feature(question_mark)]
 #![feature(never_type)]
+#![cfg_attr(not(stage0), feature(i128_type))]
 #![feature(prelude_import)]
 
 #[prelude_import]

src/librustc_i128/lib.rs

@@ -1,4 +1,5 @@
 #![allow(non_camel_case_types)]
+#![feature(i128_type)]
 
 #[cfg(stage0)]
 pub type i128 = i64;

src/librustc_resolve/lib.rs

@@ -57,6 +57,7 @@ use syntax::ast::{self, FloatTy};
 use syntax::ast::{CRATE_NODE_ID, Name, NodeId, CrateNum, IntTy, UintTy};
 use syntax::parse::token::{self, keywords};
 use syntax::util::lev_distance::find_best_match_for_name;
+use syntax::feature_gate::{emit_feature_err, GateIssue};
 
 use syntax::visit::{self, FnKind, Visitor};
 use syntax::ast::{Arm, BindingMode, Block, Crate, Expr, ExprKind};
@@ -2457,11 +2458,20 @@ impl<'a> Resolver<'a> {
         let resolve_identifier_with_fallback = |this: &mut Self, record_used| {
             let def = this.resolve_identifier(last_ident, namespace, record_used);
             match def {
-                None | Some(LocalDef{def: Def::Mod(..), ..}) if namespace == TypeNS =>
-                    this.primitive_type_table
-                        .primitive_types
-                        .get(&last_ident.name)
-                        .map_or(def, |prim_ty| Some(LocalDef::from_def(Def::PrimTy(*prim_ty)))),
+                None | Some(LocalDef{def: Def::Mod(..), ..}) if namespace == TypeNS => {
+                    let prim = this.primitive_type_table.primitive_types.get(&last_ident.name);
+                    match prim {
+                        Some(&TyUint(UintTy::U128)) | Some(&TyInt(IntTy::I128)) => {
+                            if !this.session.features.borrow().i128_type {
+                                emit_feature_err(&this.session.parse_sess.span_diagnostic,
+                                                 "i128_type", span, GateIssue::Language,
+                                                 "128-bit type is unstable");
+                            }
+                        }
+                        _ => {}
+                    }
+                    prim.map_or(def, |prim_ty| Some(LocalDef::from_def(Def::PrimTy(*prim_ty))))
+                }
                 _ => def
             }
         };

src/librustc_typeck/check/mod.rs

@@ -1262,6 +1262,13 @@ pub fn check_enum_variants<'a,'tcx>(ccx: &CrateCtxt<'a,'tcx>,
     }
 
     let repr_type_ty = ccx.tcx.enum_repr_type(Some(&hint)).to_ty(ccx.tcx);
+    if repr_type_ty == ccx.tcx.types.i128 || repr_type_ty == ccx.tcx.types.u128 {
+        if !ccx.tcx.sess.features.borrow().i128_type {
+            emit_feature_err(&ccx.tcx.sess.parse_sess.span_diagnostic,
+                             "i128_type", sp, GateIssue::Language, "128-bit type is unstable");
+        }
+    }
+
     for v in vs {
         if let Some(ref e) = v.node.disr_expr {
             check_const_with_type(ccx, e, repr_type_ty, e.id);

src/libsyntax/feature_gate.rs

@@ -283,7 +283,10 @@ declare_features! (
     (active, relaxed_adts, "1.12.0", Some(35626)),
 
     // The `!` type
-    (active, never_type, "1.13.0", Some(35121))
+    (active, never_type, "1.13.0", Some(35121)),
+
+    // The `i128` type
+    (active, i128_type, "1.13.0", Some(35118))
 );
 
 declare_features! (
@@ -993,6 +996,18 @@ impl<'a> Visitor for PostExpansionVisitor<'a> {
             ast::ExprKind::InPlace(..) => {
                 gate_feature_post!(&self, placement_in_syntax, e.span, EXPLAIN_PLACEMENT_IN);
             }
+            ast::ExprKind::Lit(ref lit) => {
+                if let ast::LitKind::Int(_, ref ty) = lit.node {
+                    match *ty {
+                        ast::LitIntType::Signed(ast::IntTy::I128) |
+                        ast::LitIntType::Unsigned(ast::UintTy::U128) => {
+                            gate_feature_post!(&self, i128_type, e.span,
+                                               "128-bit integers are not stable");
+                        }
+                        _ => {}
+                    }
+                }
+            }
             _ => {}
         }
         visit::walk_expr(self, e);

src/test/compile-fail/i128-feature-2.rs

@@ -0,0 +1,20 @@
+fn test1() -> i128 { //~ ERROR 128-bit type is unstable
+    0
+}
+
+fn test1_2() -> u128 { //~ ERROR 128-bit type is unstable
+    0
+}
+
+fn test3() {
+    let x: i128 = 0; //~ ERROR 128-bit type is unstable
+}
+
+fn test3_2() {
+    let x: u128 = 0; //~ ERROR 128-bit type is unstable
+}
+
+#[repr(u128)]
+enum A { //~ ERROR 128-bit type is unstable
+    A(u64)
+}

src/test/compile-fail/i128-feature.rs

@@ -0,0 +1,8 @@
+fn test2() {
+    0i128; //~ ERROR 128-bit integers are not stable
+}
+
+fn test2_2() {
+    0u128; //~ ERROR 128-bit integers are not stable
+}
+

src/test/run-pass/i128.rs

@@ -1,3 +1,5 @@
+#![feature(i128_type)]
+
 fn main() {
     let x: i128 = -1;
     assert_eq!(0, !x);

src/test/run-pass/u128.rs

@@ -1,8 +1,15 @@
+#![feature(i128_type)]
+
 fn main() {
     let x: u128 = 0xFFFF_FFFF_FFFF_FFFF__FFFF_FFFF_FFFF_FFFF;
     assert_eq!(0, !x);
+    assert_eq!(0, !x);
     let y: u128 = 0xFFFF_FFFF_FFFF_FFFF__FFFF_FFFF_FFFF_FFFE;
     assert_eq!(!1, y);
+    assert_eq!(x, y | 1);
+    assert_eq!(0xFAFF_0000_FF8F_0000__FFFF_0000_FFFF_FFFE,
+               y &
+               0xFAFF_0000_FF8F_0000__FFFF_0000_FFFF_FFFF);
     let z: u128 = 0xABCD_EF;
     assert_eq!(z * z * z * z, 0x33EE_0E2A_54E2_59DA_A0E7_8E41);
     assert_eq!(z + z + z + z, 0x2AF3_7BC);
@@ -13,6 +20,8 @@ fn main() {
     assert_eq!(0x1000_0000_0000_0000_0000_0000_0000_000,
                k - 0x234_5678_9ABC_DEFF_EDCB_A987_6543_210);
     assert_eq!(0x6EF5_DE4C_D3BC_2AAA_3BB4_CC5D_D6EE_8, k / 42);
+    assert_eq!(0, k % 42);
+    assert_eq!(15, z % 42);
     assert_eq!(0x91A2_B3C4_D5E6_F7, k >> 65);
     assert_eq!(0xFDB9_7530_ECA8_6420_0000_0000_0000_0000, k << 65);
     assert!(k > z);