---

yaml
---
r: 165610
b: refs/heads/master
c: 86d8579
h: refs/heads/master
v: v3

Author: Jorge Aparicio

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 5ba6102657a892457063d2d6a7cbb9632ce282c6
+refs/heads/master: 86d85794789e7a4557e3e92c402f57ae05b35e9e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 658529467d9d69ac9e09cacf98a6d61d781c2c76
 refs/heads/try: aee614fc4973262a5a68efc643026e2b1458d65b

trunk/mk/cfg/x86_64-unknown-dragonfly.mk

@@ -7,9 +7,9 @@ CFG_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).so
 CFG_STATIC_LIB_NAME_x86_64-unknown-dragonfly=lib$(1).a
 CFG_LIB_GLOB_x86_64-unknown-dragonfly=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_x86_64-unknown-dragonfly=$(1)-*.dylib.dSYM
-CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -m64 -I/usr/include -I/usr/local/include $(CFLAGS)
-CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt -m64
+CFG_JEMALLOC_CFLAGS_x86_64-unknown-dragonfly := -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_CFLAGS_x86_64-unknown-dragonfly := -Wall -Werror -g -fPIC -I/usr/include -I/usr/local/include $(CFLAGS)
+CFG_GCCISH_LINK_FLAGS_x86_64-unknown-dragonfly := -shared -fPIC -g -pthread  -lrt
 CFG_GCCISH_DEF_FLAG_x86_64-unknown-dragonfly := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-whole-archive
 CFG_GCCISH_POST_LIB_FLAGS_x86_64-unknown-dragonfly := -Wl,-no-whole-archive

trunk/src/doc/reference.md

@@ -640,7 +640,7 @@ names, and invoked through a consistent syntax: `name!(...)`. Examples include:
 * `stringify!` : pretty-print the Rust expression given as an argument
 * `include!` : include the Rust expression in the given file
 * `include_str!` : include the contents of the given file as a string
-* `include_bytes!` : include the contents of the given file as a binary blob
+* `include_bin!` : include the contents of the given file as a binary blob
 * `error!`, `warn!`, `info!`, `debug!` : provide diagnostic information.
 
 All of the above extensions are expressions with values.

trunk/src/etc/snapshot.py

@@ -37,7 +37,6 @@ def scrub(b):
     "macos": ["bin/rustc"],
     "winnt": ["bin/rustc.exe"],
     "freebsd": ["bin/rustc"],
-    "dragonfly": ["bin/rustc"],
     }
 
 winnt_runtime_deps_32 = ["libgcc_s_dw2-1.dll",
@@ -87,8 +86,6 @@ def get_kernel(triple):
         return "macos"
     if os_name == "freebsd":
         return "freebsd"
-    if os_name == "dragonfly":
-        return "dragonfly"
     return "linux"
 
 def get_cpu(triple):

trunk/src/libcore/iter.rs

@@ -2542,64 +2542,6 @@ impl<A: Int> Iterator<A> for RangeStepInclusive<A> {
     }
 }
 
-
-/// The `Step` trait identifies objects which can be stepped over in both
-/// directions. The `steps_between` function provides a way to
-/// compare two Step objects (it could be provided using `step()` and `Ord`,
-/// but the implementation would be so inefficient as to be useless).
-#[unstable = "Trait is unstable."]
-pub trait Step: Ord {
-    /// Change self to the next object.
-    fn step(&mut self);
-    /// Change self to the previous object.
-    fn step_back(&mut self);
-    /// The steps_between two step objects.
-    /// a should always be less than b, so the result should never be negative.
-    /// Return None if it is not possible to calculate steps_between without
-    /// overflow.
-    fn steps_between(a: &Self, b: &Self) -> Option<uint>;
-}
-
-macro_rules! step_impl {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(a: &$t, b: &$t) -> Option<uint> {
-                debug_assert!(a < b);
-                Some((*a - *b) as uint)
-            }
-        }
-    )*)
-}
-
-macro_rules! step_impl_no_between {
-    ($($t:ty)*) => ($(
-        #[unstable = "Trait is unstable."]
-        impl Step for $t {
-            #[inline]
-            fn step(&mut self) { *self += 1; }
-            #[inline]
-            fn step_back(&mut self) { *self -= 1; }
-            #[inline]
-            fn steps_between(_a: &$t, _b: &$t) -> Option<uint> {
-                None
-            }
-        }
-    )*)
-}
-
-step_impl!(uint u8 u16 u32 int i8 i16 i32);
-#[cfg(target_word_size = "64")]
-step_impl!(u64 i64);
-#[cfg(target_word_size = "32")]
-step_impl_no_between!(u64 i64);
-
-
 /// An iterator that repeats an element endlessly
 #[deriving(Clone)]
 #[stable]

trunk/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, associated_types)]
+#![feature(default_type_params, unboxed_closures)]
 #![deny(missing_docs)]
 
 mod macros;

trunk/src/libcore/ops.rs

@@ -51,10 +51,7 @@
 //! See the documentation for each trait for a minimum implementation that prints
 //! something to the screen.
 
-use clone::Clone;
-use iter::{Step, Iterator,DoubleEndedIterator,ExactSizeIterator};
 use kinds::Sized;
-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'.
@@ -836,79 +833,6 @@ 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;
 }
 
-
-/// An unbounded range.
-#[deriving(Copy)]
-#[lang="full_range"]
-pub struct FullRange;
-
-/// A (half-open) range which is bounded at both ends.
-#[deriving(Copy)]
-#[lang="range"]
-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 + Step<T=uint>> Iterator<Idx> for Range<Idx> {
-impl<Idx: Clone + Step> Iterator<Idx> for Range<Idx> {
-    #[inline]
-    fn next(&mut self) -> Option<Idx> {
-        if self.start < self.end {
-            let result = self.start.clone();
-            self.start.step();
-            return Some(result);
-        }
-
-        return None;
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        if let Some(hint) = Step::steps_between(&self.end, &self.start) {
-            (hint, Some(hint))
-        } else {
-            (0, None)
-        }
-    }
-}
-
-impl<Idx: Clone + Step> DoubleEndedIterator<Idx> for Range<Idx> {
-    #[inline]
-    fn next_back(&mut self) -> Option<Idx> {
-        if self.start < self.end {
-            self.end.step_back();
-            return Some(self.end.clone());
-        }
-
-        return None;
-    }
-}
-
-impl<Idx: Clone + Step> ExactSizeIterator<Idx> for Range<Idx> {}
-
-/// A range which is only bounded below.
-#[deriving(Copy)]
-#[lang="range_from"]
-pub struct RangeFrom<Idx> {
-    /// The lower bound of the range (inclusive).
-    pub start: Idx,
-}
-
-impl<Idx: Clone + Step> 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.step();
-        return Some(result);
-    }
-}
-
-
 /// The `Deref` trait is used to specify the functionality of dereferencing
 /// operations like `*v`.
 ///

trunk/src/libcoretest/ops.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use test::Bencher;
-use core::ops::{Range, FullRange, RangeFrom};
 
 // Overhead of dtors
 
@@ -28,35 +27,3 @@ 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 };
-    let mut count = 0u;
-    for (i, ri) in r.enumerate() {
-        assert!(ri == i + 2);
-        assert!(ri >= 2u && ri < 10u);
-        count += 1;
-    }
-    assert!(count == 8);
-}
-
-#[test]
-fn test_range_from() {
-    let r = RangeFrom { start: 2u };
-    let mut count = 0u;
-    for (i, ri) in r.take(10).enumerate() {
-        assert!(ri == i + 2);
-        assert!(ri >= 2u && ri < 12u);
-        count += 1;
-    }
-    assert!(count == 10);
-}
-
-#[test]
-fn test_full_range() {
-    // Not much to test.
-    let _ = FullRange;
-}

trunk/src/liblibc/lib.rs

@@ -1095,7 +1095,6 @@ pub mod types {
                 pub type sighandler_t = size_t;
             }
             pub mod bsd44 {
-                use types::common::c95::{c_void};
                 use types::os::arch::c95::{c_char, c_int, c_uint};
 
                 pub type socklen_t = u32;
@@ -1168,17 +1167,6 @@ pub mod types {
                     pub sun_family: sa_family_t,
                     pub sun_path: [c_char, ..104]
                 }
-                #[repr(C)]
-                #[deriving(Copy)] pub struct ifaddrs {
-                    pub ifa_next: *mut ifaddrs,
-                    pub ifa_name: *mut c_char,
-                    pub ifa_flags: c_uint,
-                    pub ifa_addr: *mut sockaddr,
-                    pub ifa_netmask: *mut sockaddr,
-                    pub ifa_dstaddr: *mut sockaddr,
-                    pub ifa_data: *mut c_void
-                }
-
             }
         }
 

trunk/src/librustc/middle/cfg/construct.rs

@@ -439,12 +439,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
                           start.iter().chain(end.iter()).map(|x| &**x))
             }
 
-            ast::ExprRange(ref start, ref end) => {
-                let fields = Some(&**start).into_iter()
-                    .chain(end.as_ref().map(|e| &**e).into_iter());
-                self.straightline(expr, pred, fields)
-            }
-
             ast::ExprUnary(_, ref e) if self.is_method_call(expr) => {
                 self.call(expr, pred, &**e, None::<ast::Expr>.iter())
             }

trunk/src/librustc/middle/expr_use_visitor.rs

@@ -465,11 +465,6 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,'tcx,TYPER> {
                 assert!(overloaded);
             }
 
-            ast::ExprRange(ref start, ref end) => {
-                self.consume_expr(&**start);
-                end.as_ref().map(|e| self.consume_expr(&**e));
-            }
-
             ast::ExprCall(ref callee, ref args) => {    // callee(args)
                 self.walk_callee(expr, &**callee);
                 self.consume_exprs(args);

trunk/src/librustc/middle/infer/error_reporting.rs

@@ -366,7 +366,6 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
             infer::MatchExpressionArm(_, _) => "match arms have incompatible types",
             infer::IfExpression(_) => "if and else have incompatible types",
             infer::IfExpressionWithNoElse(_) => "if may be missing an else clause",
-            infer::RangeExpression(_) => "start and end of range have incompatible types",
             infer::EquatePredicate(_) => "equality predicate not satisfied",
         };
 
@@ -1491,9 +1490,6 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> {
                     infer::IfExpressionWithNoElse(_) => {
                         format!("if may be missing an else clause")
                     }
-                    infer::RangeExpression(_) => {
-                        format!("start and end of range have compatible types")
-                    }
                     infer::EquatePredicate(_) => {
                         format!("equality where clause is satisfied")
                     }

trunk/src/librustc/middle/infer/mod.rs

@@ -127,9 +127,6 @@ pub enum TypeOrigin {
     // Computing common supertype of an if expression with no else counter-part
     IfExpressionWithNoElse(Span),
 
-    // Computing common supertype in a range expression
-    RangeExpression(Span),
-
     // `where a == b`
     EquatePredicate(Span),
 }
@@ -1087,7 +1084,6 @@ impl TypeOrigin {
             MatchExpressionArm(match_span, _) => match_span,
             IfExpression(span) => span,
             IfExpressionWithNoElse(span) => span,
-            RangeExpression(span) => span,
             EquatePredicate(span) => span,
         }
     }
@@ -1121,9 +1117,6 @@ impl<'tcx> Repr<'tcx> for TypeOrigin {
             IfExpressionWithNoElse(a) => {
                 format!("IfExpressionWithNoElse({})", a.repr(tcx))
             }
-            RangeExpression(a) => {
-                format!("RangeExpression({})", a.repr(tcx))
-            }
             EquatePredicate(a) => {
                 format!("EquatePredicate({})", a.repr(tcx))
             }

trunk/src/librustc/middle/lang_items.rs

@@ -267,9 +267,6 @@ lets_do_this! {
     IndexMutTraitLangItem,           "index_mut",               index_mut_trait;
     SliceTraitLangItem,              "slice",                   slice_trait;
     SliceMutTraitLangItem,           "slice_mut",               slice_mut_trait;
-    RangeStructLangItem,             "range",                   range_struct;
-    RangeFromStructLangItem,         "range_from",              range_from_struct;
-    FullRangeStructLangItem,         "full_range",              full_range_struct;
 
     UnsafeTypeLangItem,              "unsafe",                  unsafe_type;
 

trunk/src/librustc/middle/liveness.rs

@@ -514,7 +514,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
       ast::ExprBlock(..) | ast::ExprAssign(..) | ast::ExprAssignOp(..) |
       ast::ExprMac(..) | ast::ExprStruct(..) | ast::ExprRepeat(..) |
       ast::ExprParen(..) | ast::ExprInlineAsm(..) | ast::ExprBox(..) |
-      ast::ExprSlice(..) | ast::ExprRange(..) => {
+      ast::ExprSlice(..) => {
           visit::walk_expr(ir, expr);
       }
     }
@@ -1197,11 +1197,6 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
             self.propagate_through_expr(&**e1, succ)
           }
 
-          ast::ExprRange(ref e1, ref e2) => {
-            let succ = e2.as_ref().map_or(succ, |e| self.propagate_through_expr(&**e, succ));
-            self.propagate_through_expr(&**e1, succ)
-          }
-
           ast::ExprBox(None, ref e) |
           ast::ExprAddrOf(_, ref e) |
           ast::ExprCast(ref e, _) |
@@ -1494,8 +1489,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
       ast::ExprBreak(..) | ast::ExprAgain(..) | ast::ExprLit(_) |
       ast::ExprBlock(..) | ast::ExprMac(..) | ast::ExprAddrOf(..) |
       ast::ExprStruct(..) | ast::ExprRepeat(..) | ast::ExprParen(..) |
-      ast::ExprClosure(..) | ast::ExprPath(..) | ast::ExprBox(..) |
-      ast::ExprSlice(..) | ast::ExprRange(..) => {
+      ast::ExprClosure(..) | ast::ExprPath(..) | ast::ExprBox(..) | ast::ExprSlice(..) => {
         visit::walk_expr(this, expr);
       }
       ast::ExprIfLet(..) => {