---

yaml
---
r: 166456
b: refs/heads/snap-stage3
c: 21ea66f
h: refs/heads/master
v: v3

Author: nrc

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 18842f89f084c52588fe7cffe07f87bf6e90796a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 96a3c7c6a051ab2f5fc01fe9e686f7fffcc87c61
+refs/heads/snap-stage3: 21ea66f47ad059279628736b31a3a8bddd2710d3
 refs/heads/try: f5d619caf9f32458680fae55526b99582ca682dd
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/src/libcore/fmt/float.rs

@@ -18,8 +18,8 @@ use char;
 use char::Char;
 use fmt;
 use iter::{range, DoubleEndedIteratorExt};
-use num::{cast, Float, ToPrimitive};
-use num::FpCategory as Fp;
+use num::{Float, FPNaN, FPInfinite, ToPrimitive};
+use num::cast;
 use ops::FnOnce;
 use result::Result::Ok;
 use slice::{mod, SliceExt};
@@ -109,11 +109,11 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     let _1: T = Float::one();
 
     match num.classify() {
-        Fp::Nan => return f("NaN".as_bytes()),
-        Fp::Infinite if num > _0 => {
+        FPNaN => return f("NaN".as_bytes()),
+        FPInfinite if num > _0 => {
             return f("inf".as_bytes());
         }
-        Fp::Infinite if num < _0 => {
+        FPInfinite if num < _0 => {
             return f("-inf".as_bytes());
         }
         _ => {}

branches/snap-stage3/src/libcore/lib.rs

@@ -59,7 +59,7 @@
 #![allow(unknown_features, raw_pointer_deriving)]
 #![feature(globs, intrinsics, lang_items, macro_rules, phase)]
 #![feature(simd, unsafe_destructor, slicing_syntax)]
-#![feature(default_type_params, unboxed_closures)]
+#![feature(default_type_params, unboxed_closures, associated_types)]
 #![deny(missing_docs)]
 
 mod macros;

branches/snap-stage3/src/libcore/num/f32.rs

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -157,23 +156,23 @@ impl Float for f32 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u32 = 0x7f800000;
         const MAN_MASK: u32 = 0x007fffff;
 
         let bits: u32 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

branches/snap-stage3/src/libcore/num/f64.rs

@@ -18,8 +18,7 @@
 
 use intrinsics;
 use mem;
-use num::Float;
-use num::FpCategory as Fp;
+use num::{Float, FPNormal, FPCategory, FPZero, FPSubnormal, FPInfinite, FPNaN};
 use num::from_str_radix;
 use option::Option;
 
@@ -165,23 +164,23 @@ impl Float for f64 {
     /// Returns `true` if the number is neither zero, infinite, subnormal or NaN.
     #[inline]
     fn is_normal(self) -> bool {
-        self.classify() == Fp::Normal
+        self.classify() == FPNormal
     }
 
     /// Returns the floating point category of the number. If only one property
     /// is going to be tested, it is generally faster to use the specific
     /// predicate instead.
-    fn classify(self) -> Fp {
+    fn classify(self) -> FPCategory {
         const EXP_MASK: u64 = 0x7ff0000000000000;
         const MAN_MASK: u64 = 0x000fffffffffffff;
 
         let bits: u64 = unsafe { mem::transmute(self) };
         match (bits & MAN_MASK, bits & EXP_MASK) {
-            (0, 0)        => Fp::Zero,
-            (_, 0)        => Fp::Subnormal,
-            (0, EXP_MASK) => Fp::Infinite,
-            (_, EXP_MASK) => Fp::Nan,
-            _             => Fp::Normal,
+            (0, 0)        => FPZero,
+            (_, 0)        => FPSubnormal,
+            (0, EXP_MASK) => FPInfinite,
+            (_, EXP_MASK) => FPNaN,
+            _             => FPNormal,
         }
     }
 

branches/snap-stage3/src/libcore/num/mod.rs

@@ -15,6 +15,8 @@
 #![stable]
 #![allow(missing_docs)]
 
+pub use self::FPCategory::*;
+
 use {int, i8, i16, i32, i64};
 use {uint, u8, u16, u32, u64};
 use {f32, f64};
@@ -1220,17 +1222,17 @@ impl_num_cast! { f64,   to_f64 }
 /// Used for representing the classification of floating point numbers
 #[deriving(Copy, PartialEq, Show)]
 #[unstable = "may be renamed"]
-pub enum FpCategory {
+pub enum FPCategory {
     /// "Not a Number", often obtained by dividing by zero
-    Nan,
+    FPNaN,
     /// Positive or negative infinity
-    Infinite ,
+    FPInfinite ,
     /// Positive or negative zero
-    Zero,
-    /// De-normalized floating point representation (less precise than `Normal`)
-    Subnormal,
+    FPZero,
+    /// De-normalized floating point representation (less precise than `FPNormal`)
+    FPSubnormal,
     /// A regular floating point number
-    Normal,
+    FPNormal,
 }
 
 /// A built-in floating point number.
@@ -1275,7 +1277,7 @@ pub trait Float
     /// Returns true if this number is neither zero, infinite, denormal, or NaN.
     fn is_normal(self) -> bool;
     /// Returns the category that this number falls into.
-    fn classify(self) -> FpCategory;
+    fn classify(self) -> FPCategory;
 
     // FIXME (#5527): These should be associated constants
 

branches/snap-stage3/src/libcore/ops.rs

@@ -51,7 +51,12 @@
 //! See the documentation for each trait for a minimum implementation that prints
 //! something to the screen.
 
+use clone::Clone;
+use cmp::Ord;
+use iter::{Iterator,DoubleEndedIterator};
 use kinds::Sized;
+use kinds::Copy;
+use option::Option::{mod, Some, None};
 
 /// The `Drop` trait is used to run some code when a value goes out of scope. This
 /// is sometimes called a 'destructor'.
@@ -833,6 +838,114 @@ pub trait SliceMut<Sized? Idx, Sized? Result> for Sized? {
     fn slice_or_fail_mut<'a>(&'a mut self, from: &Idx, to: &Idx) -> &'a mut Result;
 }
 
+
+
+/// REVIEW could be in a better module
+/// The `Countable` trait identifies objects which are countable, i.e., are
+/// analogous to the natural numbers. A countable object can be incremented and
+/// and decremented and ordered. The `difference` function provides a way to
+/// compare two Countable objects (it could be provided using increment and Ord,
+/// but the implementation would be so inefficient as to be useless).
+#[unstable = "Trait is unstable."]
+pub trait Countable: Ord {
+    // FIXME(#19391) needs a snapshot
+    //type T;
+
+    /// Change self to the next object.
+    fn increment(&mut self);
+    /// Change self to the previous object.
+    fn decrement(&mut self);
+    /// The difference between two countable objects.
+    /// Temporarily a uint, should be an associated type, but
+    // FIXME(#19391) needs a snapshot
+    fn difference(a: &Self, b: &Self) -> uint;
+    //fn difference(a: &Self, b: &Self) -> <Self as Countable>::T;
+}
+
+macro_rules! countable_impl(
+    ($($t:ty)*) => ($(
+        #[unstable = "Trait is unstable."]
+        impl Countable for $t {
+            // FIXME(#19391) needs a snapshot
+            //type T = uint;
+
+            #[inline]
+            fn increment(&mut self) { *self += 1; }
+            #[inline]
+            fn decrement(&mut self) { *self -= 1; }
+            #[inline]
+            fn difference(a: &$t, b: &$t) -> uint { (*a - *b) as uint }
+        }
+    )*)
+)
+
+countable_impl!(uint u8 u16 u32 u64 int i8 i16 i32 i64)
+
+/// An unbounded range.
+pub struct FullRange;
+
+/// A range which i bounded at both ends.
+pub struct Range<Idx> {
+    /// The lower bound of the range (inclusive).
+    pub start: Idx,
+    /// The upper bound of the range (exclusive).
+    pub end: Idx,
+}
+
+// FIXME(#19391) needs a snapshot
+//impl<Idx: Clone + Countable<T=uint>> Iterator<Idx> for Range<Idx> {
+impl<Idx: Clone + Countable> Iterator<Idx> for Range<Idx> {
+    #[inline]
+    fn next(&mut self) -> Option<Idx> {
+        if self.start < self.end {
+            let result = self.start.clone();
+            self.start.increment();
+            return Some(result);
+        }
+
+        return None;
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (uint, Option<uint>) {
+        let hint = Countable::difference(&self.end, &self.start);
+        (hint, Some(hint))
+    }
+}
+
+impl<Idx: Clone + Countable> DoubleEndedIterator<Idx> for Range<Idx> {
+    #[inline]
+    fn next_back(&mut self) -> Option<Idx> {
+        if self.start < self.end {
+            self.end.decrement();
+            return Some(self.end.clone());
+        }
+
+        return None;
+    }
+}
+
+/// A range which is only bounded below.
+pub struct RangeFrom<Idx> {
+    /// The lower bound of the range (inclusive).
+    pub start: Idx,
+}
+
+impl<Idx: Clone + Countable> Iterator<Idx> for RangeFrom<Idx> {
+    #[inline]
+    fn next(&mut self) -> Option<Idx> {
+        // Deliberately overflow so we loop forever.
+        let result = self.start.clone();
+        self.start.increment();
+        return Some(result);
+    }
+}
+
+impl<Idx: Copy> Copy for Range<Idx> {}
+impl<Idx: Copy> Copy for RangeFrom<Idx> {}
+impl Copy for FullRange {}
+
+
 /// The `Deref` trait is used to specify the functionality of dereferencing
 /// operations like `*v`.
 ///

branches/snap-stage3/src/libcoretest/ops.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use test::Bencher;
+use core::ops::{Range, FullRange, RangeFrom};
 
 // Overhead of dtors
 
@@ -27,3 +28,29 @@ fn alloc_obj_with_dtor(b: &mut Bencher) {
         HasDtor { _x : 10 };
     })
 }
+
+// Test the Range structs without the syntactic sugar.
+
+#[test]
+fn test_range() {
+    let r = Range { start: 2u, end: 10 };
+    for (i, ri) in r.enumerate() {
+        assert!(ri == i + 2);
+        assert!(ri >= 2u && ri < 10u);
+    }
+}
+
+#[test]
+fn test_range_from() {
+    let r = RangeFrom { start: 2u };
+    for (i, ri) in r.take(10).enumerate() {
+        assert!(ri == i + 2);
+        assert!(ri >= 2u && ri < 12u);
+    }
+}
+
+#[test]
+fn test_full_range() {
+    // Not much to test.
+    let _ = FullRange;
+}

branches/snap-stage3/src/librustc/middle/ty.rs

@@ -4212,14 +4212,10 @@ pub fn expr_kind(tcx: &ctxt, expr: &ast::Expr) -> ExprKind {
                 }
 
                 def::DefStruct(_) => {
-                    match tcx.node_types.borrow().get(&expr.id) {
-                        Some(ty) => match ty.sty {
-                            ty_bare_fn(..) => RvalueDatumExpr,
-                            _ => RvalueDpsExpr
-                        },
-                        // See ExprCast below for why types might be missing.
-                        None => RvalueDatumExpr
-                     }
+                    match expr_ty(tcx, expr).sty {
+                        ty_bare_fn(..) => RvalueDatumExpr,
+                        _ => RvalueDpsExpr
+                    }
                 }
 
                 // Special case: A unit like struct's constructor must be called without () at the