---

yaml
---
r: 151029
b: refs/heads/try2
c: c3b2f2b
h: refs/heads/master
i:
  151027: 6fd27f1
v: v3

Author: nrc

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: bcc3e8c0d44bbbbf752db45a9c85f7ac4b4d61ce
+refs/heads/try2: c3b2f2b0c6f074fb98add56a1977d407e294c9ed
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/tutorial.md

@@ -2253,7 +2253,7 @@ defining one.
 
 The type parameters bound by a trait are in scope in each of the
 method declarations. So, re-declaring the type parameter
-`T` as an explicit type parameter for `length`, in either the trait or
+`T` as an explicit type parameter for `len`, in either the trait or
 the impl, would be a compile-time error.
 
 Within a trait definition, `Self` is a special type that you can think

branches/try2/src/libhexfloat/lib.rs

@@ -105,7 +105,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

branches/try2/src/librustc/front/feature_gate.rs

@@ -57,8 +57,6 @@ static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[
     ("linkage", Active),
     ("struct_inherit", Active),
 
-    ("quad_precision_float", Active),
-
     // These are used to test this portion of the compiler, they don't actually
     // mean anything
     ("test_accepted_feature", Accepted),
@@ -79,15 +77,13 @@ 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 default_type_params: Cell<bool>
 }
 
 impl Features {
     pub fn new() -> Features {
         Features {
-            default_type_params: Cell::new(false),
-            quad_precision_float: Cell::new(false)
+            default_type_params: Cell::new(false)
         }
     }
 }
@@ -368,5 +364,4 @@ 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"));
 }

branches/try2/src/librustc/metadata/tydecode.rs

@@ -317,7 +317,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")
         }
       }

branches/try2/src/librustc/metadata/tyencode.rs

@@ -236,7 +236,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) => {

branches/try2/src/librustc/middle/resolve.rs

@@ -772,7 +772,6 @@ fn PrimitiveTypeTable() -> 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));

branches/try2/src/librustc/middle/trans/debuginfo.rs

@@ -1170,8 +1170,7 @@ fn basic_type_metadata(cx: &CrateContext, t: ty::t) -> DIType {
         },
         ty::ty_float(float_ty) => match float_ty {
             ast::TyF32 => ("f32".to_owned(), DW_ATE_float),
-            ast::TyF64 => ("f64".to_owned(), DW_ATE_float),
-            ast::TyF128 => ("f128".to_owned(), DW_ATE_float)
+            ast::TyF64 => ("f64".to_owned(), DW_ATE_float)
         },
         _ => cx.sess().bug("debuginfo::basic_type_metadata - t is invalid type")
     };

branches/try2/src/librustc/middle/trans/reflect.rs

@@ -163,7 +163,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 str_*/vec_*.
           ty::ty_str(vst) => {

branches/try2/src/librustc/middle/trans/type_.rs

@@ -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::i8(ccx)
     }
@@ -134,8 +130,7 @@ impl Type {
     pub fn float_from_ty(ccx: &CrateContext, t: ast::FloatTy) -> Type {
         match t {
             ast::TyF32 => Type::f32(ccx),
-            ast::TyF64 => Type::f64(ccx),
-            ast::TyF128 => Type::f128(ccx)
+            ast::TyF64 => Type::f64(ccx)
         }
     }
 

branches/try2/src/librustc/middle/ty.rs

@@ -706,7 +706,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,
@@ -1306,9 +1305,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) }
 
@@ -1348,7 +1344,6 @@ pub fn mk_mach_float(tm: ast::FloatTy) -> t {
     match tm {
         ast::TyF32  => mk_f32(),
         ast::TyF64  => mk_f64(),
-        ast::TyF128 => mk_f128()
     }
 }
 

branches/try2/src/librustc/middle/typeck/astconv.rs

@@ -341,13 +341,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))
                         }

branches/try2/src/librustdoc/html/format.rs

@@ -332,7 +332,6 @@ impl fmt::Show for clean::Type {
                     ast::TyUint(ast::TyU64) => "u64",
                     ast::TyFloat(ast::TyF32) => "f32",
                     ast::TyFloat(ast::TyF64) => "f64",
-                    ast::TyFloat(ast::TyF128) => "f128",
                     ast::TyStr => "str",
                     ast::TyBool => "bool",
                     ast::TyChar => "char",

branches/try2/src/libstd/intrinsics.rs

@@ -95,8 +95,6 @@ pub trait TyVisitor {
 
     fn visit_f32(&mut self) -> bool;
     fn visit_f64(&mut self) -> bool;
-    #[cfg(not(stage0))]
-    fn visit_f128(&mut self) -> bool;
 
     fn visit_char(&mut self) -> bool;
 

branches/try2/src/libstd/lib.rs

@@ -52,13 +52,11 @@
        html_favicon_url = "http://www.rust-lang.org/favicon.ico",
        html_root_url = "http://static.rust-lang.org/doc/master")]
 #![feature(macro_rules, globs, asm, managed_boxes, thread_local, link_args,
-           simd, linkage, default_type_params, phase, concat_idents, quad_precision_float)]
+           simd, linkage, default_type_params, phase, concat_idents)]
 
 // Don't link to std. We are std.
 #![no_std]
 
-// NOTE: remove after snapshot
-#![allow(unknown_features)]
 #![deny(missing_doc)]
 
 // When testing libstd, bring in libuv as the I/O backend so tests can print

branches/try2/src/libstd/reflect.rs

@@ -176,14 +176,6 @@ impl<V:TyVisitor + MovePtr> TyVisitor for MovePtrAdaptor<V> {
         true
     }
 
-    #[cfg(not(stage0))]
-    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; }

branches/try2/src/libstd/repr.rs

@@ -280,8 +280,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>() }
-    #[cfg(not(stage0))]
-    fn visit_f128(&mut self) -> bool { fail!("not implemented") }
 
     fn visit_char(&mut self) -> bool {
         self.get::<char>(|this, &ch| {

branches/try2/src/libsyntax/ast.rs

@@ -181,7 +181,8 @@ pub struct TyParam {
     pub ident: Ident,
     pub id: NodeId,
     pub bounds: OwnedSlice<TyParamBound>,
-    pub default: Option<P<Ty>>
+    pub default: Option<P<Ty>>,
+    pub span: Span
 }
 
 #[deriving(Clone, Eq, TotalEq, Encodable, Decodable, Hash)]
@@ -730,7 +731,6 @@ impl fmt::Show for UintTy {
 pub enum FloatTy {
     TyF32,
     TyF64,
-    TyF128
 }
 
 impl fmt::Show for FloatTy {

branches/try2/src/libsyntax/ast_util.rs

@@ -187,7 +187,7 @@ pub fn uint_ty_max(t: UintTy) -> u64 {
 }
 
 pub fn float_ty_to_str(t: FloatTy) -> ~str {
-    match t { TyF32 => "f32".to_owned(), TyF64 => "f64".to_owned(), TyF128 => "f128".to_owned() }
+    match t { TyF32 => "f32".to_owned(), TyF64 => "f64".to_owned() }
 }
 
 pub fn is_call_expr(e: @Expr) -> bool {

branches/try2/src/libsyntax/ext/build.rs

@@ -66,6 +66,7 @@ pub trait AstBuilder {
     fn strip_bounds(&self, bounds: &Generics) -> Generics;
 
     fn typaram(&self,
+               span: Span,
                id: ast::Ident,
                bounds: OwnedSlice<ast::TyParamBound>,
                default: Option<P<ast::Ty>>) -> ast::TyParam;
@@ -368,14 +369,16 @@ impl<'a> AstBuilder for ExtCtxt<'a> {
     }
 
     fn typaram(&self,
+               span: Span,
                id: ast::Ident,
                bounds: OwnedSlice<ast::TyParamBound>,
                default: Option<P<ast::Ty>>) -> ast::TyParam {
         ast::TyParam {
             ident: id,
             id: ast::DUMMY_NODE_ID,
             bounds: bounds,
-            default: default
+            default: default,
+            span: span
         }
     }
 

branches/try2/src/libsyntax/ext/deriving/generic.rs

@@ -380,7 +380,7 @@ impl<'a> TraitDef<'a> {
             // require the current trait
             bounds.push(cx.typarambound(trait_path.clone()));
 
-            cx.typaram(ty_param.ident, OwnedSlice::from_vec(bounds), None)
+            cx.typaram(self.span, ty_param.ident, OwnedSlice::from_vec(bounds), None)
         }));
         let trait_generics = Generics {
             lifetimes: lifetimes,

branches/try2/src/libsyntax/ext/deriving/ty.rs

@@ -193,7 +193,7 @@ fn mk_ty_param(cx: &ExtCtxt, span: Span, name: &str, bounds: &[Path],
             let path = b.to_path(cx, span, self_ident, self_generics);
             cx.typarambound(path)
         }).collect();
-    cx.typaram(cx.ident_of(name), bounds, None)
+    cx.typaram(span, cx.ident_of(name), bounds, None)
 }
 
 fn mk_generics(lifetimes: Vec<ast::Lifetime> ,  ty_params: Vec<ast::TyParam> ) -> Generics {

branches/try2/src/libsyntax/ext/quote.rs

@@ -436,8 +436,7 @@ fn mk_token(cx: &ExtCtxt, sp: Span, tok: &token::Token) -> @ast::Expr {
         LIT_FLOAT(fident, fty) => {
             let s_fty = match fty {
                 ast::TyF32 => "TyF32".to_owned(),
-                ast::TyF64 => "TyF64".to_owned(),
-                ast::TyF128 => "TyF128".to_owned()
+                ast::TyF64 => "TyF64".to_owned()
             };
             let e_fty = cx.expr_ident(sp, id_ext(s_fty));
 

branches/try2/src/libsyntax/fold.rs

@@ -448,7 +448,8 @@ pub fn fold_ty_param<T: Folder>(tp: &TyParam, fld: &mut T) -> TyParam {
         ident: tp.ident,
         id: id,
         bounds: tp.bounds.map(|x| fold_ty_param_bound(x, fld)),
-        default: tp.default.map(|x| fld.fold_ty(x))
+        default: tp.default.map(|x| fld.fold_ty(x)),
+        span: tp.span
     }
 }
 

branches/try2/src/libsyntax/parse/lexer.rs

@@ -593,15 +593,10 @@ fn scan_number(c: char, rdr: &mut StringReader) -> token::Token {
             /* 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' && nextnextch(rdr).unwrap_or('\x00') == '8' {
-            bump(rdr);
-            bump(rdr);
-            bump(rdr);
-            check_float_base(rdr, start_bpos, rdr.last_pos, base);
-            return token::LIT_FLOAT(str_to_ident(num_str.as_slice()), ast::TyF128);
+        } else {
+            fatal_span(rdr, start_bpos, rdr.last_pos,
+                       "expected `f32` or `f64` suffix".to_owned());
         }
-        fatal_span(rdr, start_bpos, rdr.last_pos,
-                   "expected `f32`, `f64` or `f128` suffix".to_owned());
     }
     if is_float {
         check_float_base(rdr, start_bpos, rdr.last_pos, base);

branches/try2/src/libsyntax/parse/parser.rs

@@ -3393,6 +3393,7 @@ impl<'a> Parser<'a> {
     // matches typaram = IDENT optbounds ( EQ ty )?
     fn parse_ty_param(&mut self) -> TyParam {
         let ident = self.parse_ident();
+        let span = self.span;
         let (_, opt_bounds) = self.parse_optional_ty_param_bounds(false);
         // For typarams we don't care about the difference b/w "<T>" and "<T:>".
         let bounds = opt_bounds.unwrap_or_default();
@@ -3407,7 +3408,8 @@ impl<'a> Parser<'a> {
             ident: ident,
             id: ast::DUMMY_NODE_ID,
             bounds: bounds,
-            default: default
+            default: default,
+            span: span,
         }
     }
 

branches/try2/src/test/run-pass/quad-precision-float.rs

@@ -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 }