Remove the quad_precision_float feature gate
The f128 type has very little support in the compiler and the feature is basically unusable today. Supporting half-baked features in the compiler can be detrimental to the long-term development of the compiler, and hence this feature is being removed.
This commit is contained in:
parent
719ffc2484
commit
3d308fe65b
|
@ -96,7 +96,6 @@ pub trait TyVisitor {
|
|||
|
||||
fn visit_f32(&mut self) -> bool;
|
||||
fn visit_f64(&mut self) -> bool;
|
||||
fn visit_f128(&mut self) -> bool;
|
||||
|
||||
fn visit_char(&mut self) -> bool;
|
||||
|
||||
|
|
|
@ -25,7 +25,7 @@
|
|||
html_favicon_url = "http://www.rust-lang.org/favicon.ico",
|
||||
html_root_url = "http://doc.rust-lang.org/")]
|
||||
#![experimental]
|
||||
#![feature(managed_boxes, macro_rules, quad_precision_float)]
|
||||
#![feature(managed_boxes, macro_rules)]
|
||||
#![allow(experimental)]
|
||||
|
||||
pub mod fmt;
|
||||
|
|
|
@ -179,13 +179,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
|
|||
true
|
||||
}
|
||||
|
||||
fn visit_f128(&mut self) -> bool {
|
||||
self.align_to::<f128>();
|
||||
if ! self.inner.visit_f128() { return false; }
|
||||
self.bump_past::<f128>();
|
||||
true
|
||||
}
|
||||
|
||||
fn visit_char(&mut self) -> bool {
|
||||
self.align_to::<char>();
|
||||
if ! self.inner.visit_char() { return false; }
|
||||
|
|
|
@ -258,7 +258,6 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
|
|||
|
||||
fn visit_f32(&mut self) -> bool { self.write::<f32>() }
|
||||
fn visit_f64(&mut self) -> bool { self.write::<f64>() }
|
||||
fn visit_f128(&mut self) -> bool { fail!("not implemented") }
|
||||
|
||||
fn visit_char(&mut self) -> bool {
|
||||
self.get::<char>(|this, &ch| {
|
||||
|
|
|
@ -112,7 +112,6 @@ pub fn expand_syntax_ext(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
|
|||
Some(Ident{ident, span}) => match token::get_ident(ident).get() {
|
||||
"f32" => Some(ast::TyF32),
|
||||
"f64" => Some(ast::TyF64),
|
||||
"f128" => Some(ast::TyF128),
|
||||
_ => {
|
||||
cx.span_err(span, "invalid floating point type in hexfloat!");
|
||||
None
|
||||
|
|
|
@ -64,7 +64,7 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
|
|||
("overloaded_calls", Active),
|
||||
("unboxed_closure_sugar", Active),
|
||||
|
||||
("quad_precision_float", Active),
|
||||
("quad_precision_float", Removed),
|
||||
|
||||
// A temporary feature gate used to enable parser extensions needed
|
||||
// to bootstrap fix for #5723.
|
||||
|
@ -91,7 +91,6 @@ enum Status {
|
|||
/// A set of features to be used by later passes.
|
||||
pub struct Features {
|
||||
pub default_type_params: Cell<bool>,
|
||||
pub quad_precision_float: Cell<bool>,
|
||||
pub issue_5723_bootstrap: Cell<bool>,
|
||||
pub overloaded_calls: Cell<bool>,
|
||||
}
|
||||
|
@ -100,7 +99,6 @@ impl Features {
|
|||
pub fn new() -> Features {
|
||||
Features {
|
||||
default_type_params: Cell::new(false),
|
||||
quad_precision_float: Cell::new(false),
|
||||
issue_5723_bootstrap: Cell::new(false),
|
||||
overloaded_calls: Cell::new(false),
|
||||
}
|
||||
|
@ -425,7 +423,6 @@ pub fn check_crate(sess: &Session, krate: &ast::Crate) {
|
|||
sess.abort_if_errors();
|
||||
|
||||
sess.features.default_type_params.set(cx.has_feature("default_type_params"));
|
||||
sess.features.quad_precision_float.set(cx.has_feature("quad_precision_float"));
|
||||
sess.features.issue_5723_bootstrap.set(cx.has_feature("issue_5723_bootstrap"));
|
||||
sess.features.overloaded_calls.set(cx.has_feature("overloaded_calls"));
|
||||
}
|
||||
|
|
|
@ -330,7 +330,6 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
|
|||
'D' => return ty::mk_mach_int(ast::TyI64),
|
||||
'f' => return ty::mk_mach_float(ast::TyF32),
|
||||
'F' => return ty::mk_mach_float(ast::TyF64),
|
||||
'Q' => return ty::mk_mach_float(ast::TyF128),
|
||||
_ => fail!("parse_ty: bad numeric type")
|
||||
}
|
||||
}
|
||||
|
|
|
@ -221,7 +221,6 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
|
|||
match t {
|
||||
TyF32 => mywrite!(w, "Mf"),
|
||||
TyF64 => mywrite!(w, "MF"),
|
||||
TyF128 => mywrite!(w, "MQ")
|
||||
}
|
||||
}
|
||||
ty::ty_enum(def, ref substs) => {
|
||||
|
|
|
@ -770,7 +770,6 @@ impl PrimitiveTypeTable {
|
|||
table.intern("char", TyChar);
|
||||
table.intern("f32", TyFloat(TyF32));
|
||||
table.intern("f64", TyFloat(TyF64));
|
||||
table.intern("f128", TyFloat(TyF128));
|
||||
table.intern("int", TyInt(TyI));
|
||||
table.intern("i8", TyInt(TyI8));
|
||||
table.intern("i16", TyInt(TyI16));
|
||||
|
|
|
@ -1621,7 +1621,6 @@ fn basic_type_metadata(cx: &CrateContext, t: ty::t) -> DIType {
|
|||
ty::ty_float(float_ty) => match float_ty {
|
||||
ast::TyF32 => ("f32".to_string(), DW_ATE_float),
|
||||
ast::TyF64 => ("f64".to_string(), DW_ATE_float),
|
||||
ast::TyF128 => ("f128".to_string(), DW_ATE_float)
|
||||
},
|
||||
_ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
|
||||
};
|
||||
|
|
|
@ -148,7 +148,6 @@ impl<'a, 'b> Reflector<'a, 'b> {
|
|||
ty::ty_uint(ast::TyU64) => self.leaf("u64"),
|
||||
ty::ty_float(ast::TyF32) => self.leaf("f32"),
|
||||
ty::ty_float(ast::TyF64) => self.leaf("f64"),
|
||||
ty::ty_float(ast::TyF128) => self.leaf("f128"),
|
||||
|
||||
// Should rename to vec_*.
|
||||
ty::ty_vec(ref mt, Some(sz)) => {
|
||||
|
|
|
@ -88,10 +88,6 @@ impl Type {
|
|||
ty!(llvm::LLVMDoubleTypeInContext(ccx.llcx))
|
||||
}
|
||||
|
||||
pub fn f128(ccx: &CrateContext) -> Type {
|
||||
ty!(llvm::LLVMFP128TypeInContext(ccx.llcx))
|
||||
}
|
||||
|
||||
pub fn bool(ccx: &CrateContext) -> Type {
|
||||
Type::i1(ccx)
|
||||
}
|
||||
|
@ -135,7 +131,6 @@ impl Type {
|
|||
match t {
|
||||
ast::TyF32 => Type::f32(ccx),
|
||||
ast::TyF64 => Type::f64(ccx),
|
||||
ast::TyF128 => Type::f128(ccx)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -694,7 +694,6 @@ mod primitives {
|
|||
def_prim_ty!(TY_U64, super::ty_uint(ast::TyU64), 12)
|
||||
def_prim_ty!(TY_F32, super::ty_float(ast::TyF32), 14)
|
||||
def_prim_ty!(TY_F64, super::ty_float(ast::TyF64), 15)
|
||||
def_prim_ty!(TY_F128, super::ty_float(ast::TyF128), 16)
|
||||
|
||||
pub static TY_BOT: t_box_ = t_box_ {
|
||||
sty: super::ty_bot,
|
||||
|
@ -1272,9 +1271,6 @@ pub fn mk_f32() -> t { mk_prim_t(&primitives::TY_F32) }
|
|||
#[inline]
|
||||
pub fn mk_f64() -> t { mk_prim_t(&primitives::TY_F64) }
|
||||
|
||||
#[inline]
|
||||
pub fn mk_f128() -> t { mk_prim_t(&primitives::TY_F128) }
|
||||
|
||||
#[inline]
|
||||
pub fn mk_uint() -> t { mk_prim_t(&primitives::TY_UINT) }
|
||||
|
||||
|
@ -1314,7 +1310,6 @@ pub fn mk_mach_float(tm: ast::FloatTy) -> t {
|
|||
match tm {
|
||||
ast::TyF32 => mk_f32(),
|
||||
ast::TyF64 => mk_f64(),
|
||||
ast::TyF128 => mk_f128()
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -355,13 +355,6 @@ pub fn ast_ty_to_prim_ty(tcx: &ty::ctxt, ast_ty: &ast::Ty) -> Option<ty::t> {
|
|||
Some(ty::mk_mach_uint(uit))
|
||||
}
|
||||
ast::TyFloat(ft) => {
|
||||
if ft == ast::TyF128 && !tcx.sess.features.quad_precision_float.get() {
|
||||
tcx.sess.span_err(path.span, "quadruple precision floats are \
|
||||
missing complete runtime support");
|
||||
tcx.sess.span_note(path.span, "add \
|
||||
#[feature(quad_precision_float)] \
|
||||
to the crate attributes to enable");
|
||||
}
|
||||
check_path_args(tcx, path, NO_TPS | NO_REGIONS);
|
||||
Some(ty::mk_mach_float(ft))
|
||||
}
|
||||
|
|
|
@ -1072,7 +1072,7 @@ pub enum Type {
|
|||
pub enum Primitive {
|
||||
Int, I8, I16, I32, I64,
|
||||
Uint, U8, U16, U32, U64,
|
||||
F32, F64, F128,
|
||||
F32, F64,
|
||||
Char,
|
||||
Bool,
|
||||
Nil,
|
||||
|
@ -1111,7 +1111,6 @@ impl Primitive {
|
|||
"str" => Some(Str),
|
||||
"f32" => Some(F32),
|
||||
"f64" => Some(F64),
|
||||
"f128" => Some(F128),
|
||||
"slice" => Some(Slice),
|
||||
"tuple" => Some(PrimitiveTuple),
|
||||
_ => None,
|
||||
|
@ -1153,7 +1152,6 @@ impl Primitive {
|
|||
U64 => "u64",
|
||||
F32 => "f32",
|
||||
F64 => "f64",
|
||||
F128 => "f128",
|
||||
Str => "str",
|
||||
Bool => "bool",
|
||||
Char => "char",
|
||||
|
@ -1227,7 +1225,6 @@ impl Clean<Type> for ty::t {
|
|||
ty::ty_uint(ast::TyU64) => Primitive(U64),
|
||||
ty::ty_float(ast::TyF32) => Primitive(F32),
|
||||
ty::ty_float(ast::TyF64) => Primitive(F64),
|
||||
ty::ty_float(ast::TyF128) => Primitive(F128),
|
||||
ty::ty_str => Primitive(Str),
|
||||
ty::ty_box(t) => Managed(box t.clean()),
|
||||
ty::ty_uniq(t) => Unique(box t.clean()),
|
||||
|
@ -2010,7 +2007,6 @@ fn resolve_type(path: Path, tpbs: Option<Vec<TyParamBound>>,
|
|||
ast::TyUint(ast::TyU64) => return Primitive(U64),
|
||||
ast::TyFloat(ast::TyF32) => return Primitive(F32),
|
||||
ast::TyFloat(ast::TyF64) => return Primitive(F64),
|
||||
ast::TyFloat(ast::TyF128) => return Primitive(F128),
|
||||
},
|
||||
def::DefTyParam(_, i, _) => return Generic(i),
|
||||
def::DefTyParamBinder(i) => return TyParamBinder(i),
|
||||
|
|
|
@ -700,7 +700,6 @@ impl fmt::Show for UintTy {
|
|||
pub enum FloatTy {
|
||||
TyF32,
|
||||
TyF64,
|
||||
TyF128
|
||||
}
|
||||
|
||||
impl fmt::Show for FloatTy {
|
||||
|
|
|
@ -179,7 +179,6 @@ pub fn float_ty_to_str(t: FloatTy) -> String {
|
|||
match t {
|
||||
TyF32 => "f32".to_string(),
|
||||
TyF64 => "f64".to_string(),
|
||||
TyF128 => "f128".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -483,7 +483,6 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> Gc<ast::Expr> {
|
|||
let s_fty = match fty {
|
||||
ast::TyF32 => "TyF32",
|
||||
ast::TyF64 => "TyF64",
|
||||
ast::TyF128 => "TyF128"
|
||||
};
|
||||
let e_fty = mk_ast_path(cx, sp, s_fty);
|
||||
let e_fident = mk_ident(cx, sp, fident);
|
||||
|
|
|
@ -639,16 +639,9 @@ impl<'a> StringReader<'a> {
|
|||
/* FIXME (#2252): if this is out of range for either a
|
||||
32-bit or 64-bit float, it won't be noticed till the
|
||||
back-end. */
|
||||
} else if c == '1' && n == '2' && self.nextnextch().unwrap_or('\x00') == '8' {
|
||||
self.bump();
|
||||
self.bump();
|
||||
self.bump();
|
||||
let last_bpos = self.last_pos;
|
||||
self.check_float_base(start_bpos, last_bpos, base);
|
||||
return token::LIT_FLOAT(str_to_ident(num_str.as_slice()), ast::TyF128);
|
||||
}
|
||||
let last_bpos = self.last_pos;
|
||||
self.err_span_(start_bpos, last_bpos, "expected `f32`, `f64` or `f128` suffix");
|
||||
self.err_span_(start_bpos, last_bpos, "expected `f32` or `f64` suffix");
|
||||
}
|
||||
if is_float {
|
||||
let last_bpos = self.last_pos;
|
||||
|
|
|
@ -1,20 +0,0 @@
|
|||
// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
#![feature(quad_precision_float)]
|
||||
|
||||
static x: f128 = 1.0 + 2.0;
|
||||
|
||||
fn foo(a: f128) -> f128 { a }
|
||||
|
||||
pub fn main() {
|
||||
let y = x;
|
||||
foo(y);
|
||||
}
|
|
@ -58,7 +58,6 @@ impl TyVisitor for MyVisitor {
|
|||
|
||||
fn visit_f32(&mut self) -> bool { true }
|
||||
fn visit_f64(&mut self) -> bool { true }
|
||||
fn visit_f128(&mut self) -> bool { true }
|
||||
|
||||
fn visit_char(&mut self) -> bool { true }
|
||||
|
||||
|
|
Loading…
Reference in New Issue