---

yaml
---
r: 55204
b: refs/heads/snap-stage3
c: 5d79f94
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 5f13e9ccc2e3328d4cd8ca49f84e6840dd998346
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: f67239fac3cc521fedaf14faf5357beab78caea8
+refs/heads/snap-stage3: 5d79f94a2f74a0502f665c5eb432aa7231666392
 refs/heads/try: 8eb2bab100b42f0ba751552d8eff00eb2134c55a
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/rust.md

@@ -1467,8 +1467,8 @@ A complete list of the built-in language items follows:
   : Elements can be subtracted.
 `mul`
   : Elements can be multiplied.
-`div`
-  : Elements have a division operation.
+`quot`
+  : Elements have a quotient operation.
 `rem`
   : Elements have a remainder operation.
 `neg`
@@ -1857,7 +1857,7 @@ The default meaning of the operators on standard types is given here.
     Calls the `mul` method on the `core::ops::Mul` trait.
 `/`
   : Quotient.
-    Calls the `div` method on the `core::ops::Div` trait.
+    Calls the `quot` method on the `core::ops::Quot` trait.
 `%`
   : Remainder.
     Calls the `rem` method on the `core::ops::Rem` trait.

branches/snap-stage3/mk/clean.mk

@@ -48,7 +48,7 @@ clean-misc:
 	$(Q)rm -f $(RUSTLLVM_LIB_OBJS) $(RUSTLLVM_OBJS_OBJS) $(RUSTLLVM_DEF)
 	$(Q)rm -Rf $(DOCS)
 	$(Q)rm -Rf $(GENERATED)
-	$(Q)rm -f tmp/*
+	$(Q)rm -f tmp/*.log tmp/*.rc tmp/*.rs tmp/*.ok
 	$(Q)rm -Rf rust-stage0-*.tar.bz2 $(PKG_NAME)-*.tar.gz dist
 	$(Q)rm -Rf $(foreach ext, \
                  html aux cp fn ky log pdf pg toc tp vr cps, \

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

@@ -10,7 +10,6 @@
 
 //! Utilities for manipulating the char type
 
-#[cfg(notest)]
 use cmp::Ord;
 use option::{None, Option, Some};
 use str;

branches/snap-stage3/src/libcore/core.rc

@@ -63,7 +63,6 @@ they contained the following prologue:
 #[warn(vecs_implicitly_copyable)];
 #[deny(non_camel_case_types)];
 #[allow(deprecated_mutable_fields)];
-#[allow(deprecated_drop)];
 
 // Make core testable by not duplicating lang items. See #2912
 #[cfg(test)] extern mod realcore(name = "core", vers = "0.7-pre");
@@ -78,7 +77,7 @@ pub use ops::{Drop};
 #[cfg(stage0)]
 pub use ops::{Add, Sub, Mul, Div, Modulo, Neg, Not};
 #[cfg(not(stage0))]
-pub use ops::{Add, Sub, Mul, Div, Rem, Neg, Not};
+pub use ops::{Add, Sub, Mul, Quot, Rem, Neg, Not};
 pub use ops::{BitAnd, BitOr, BitXor};
 pub use ops::{Shl, Shr, Index};
 

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

@@ -41,9 +41,6 @@ much easier to implement.
 
 */
 
-use cmp::Ord;
-use option::{Option, Some, None};
-
 pub trait Times {
     fn times(&self, it: &fn() -> bool);
 }
@@ -107,78 +104,6 @@ pub fn all<T>(predicate: &fn(T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> bool {
     true
 }
 
-/**
- * Return the first element where `predicate` returns `true`. Return `None` if no element is found.
- *
- * # Example:
- *
- * ~~~~
- * let xs = ~[1u, 2, 3, 4, 5, 6];
- * assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.each(f)).unwrap(), 4);
- * ~~~~
- */
-#[inline(always)]
-pub fn find<T>(predicate: &fn(&T) -> bool, iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
-    for iter |x| {
-        if predicate(&x) {
-            return Some(x);
-        }
-    }
-    None
-}
-
-/**
- * Return the largest item yielded by an iterator. Return `None` if the iterator is empty.
- *
- * # Example:
- *
- * ~~~~
- * let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
- * assert_eq!(max(|f| xs.each(f)).unwrap(), &15);
- * ~~~~
- */
-#[inline]
-pub fn max<T: Ord>(iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
-    let mut result = None;
-    for iter |x| {
-        match result {
-            Some(ref mut y) => {
-                if x > *y {
-                    *y = x;
-                }
-            }
-            None => result = Some(x)
-        }
-    }
-    result
-}
-
-/**
- * Return the smallest item yielded by an iterator. Return `None` if the iterator is empty.
- *
- * # Example:
- *
- * ~~~~
- * let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
- * assert_eq!(max(|f| xs.each(f)).unwrap(), &-5);
- * ~~~~
- */
-#[inline]
-pub fn min<T: Ord>(iter: &fn(f: &fn(T) -> bool)) -> Option<T> {
-    let mut result = None;
-    for iter |x| {
-        match result {
-            Some(ref mut y) => {
-                if x < *y {
-                    *y = x;
-                }
-            }
-            None => result = Some(x)
-        }
-    }
-    result
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -203,22 +128,4 @@ mod tests {
         assert!(all(|x: uint| x < 6, |f| uint::range(1, 6, f)));
         assert!(!all(|x: uint| x < 5, |f| uint::range(1, 6, f)));
     }
-
-    #[test]
-    fn test_find() {
-        let xs = ~[1u, 2, 3, 4, 5, 6];
-        assert_eq!(*find(|& &x: & &uint| x > 3, |f| xs.each(f)).unwrap(), 4);
-    }
-
-    #[test]
-    fn test_max() {
-        let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
-        assert_eq!(max(|f| xs.each(f)).unwrap(), &15);
-    }
-
-    #[test]
-    fn test_min() {
-        let xs = ~[8, 2, 3, 1, -5, 9, 11, 15];
-        assert_eq!(min(|f| xs.each(f)).unwrap(), &-5);
-    }
 }

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

@@ -123,7 +123,7 @@ pub fn sub(x: f32, y: f32) -> f32 { return x - y; }
 pub fn mul(x: f32, y: f32) -> f32 { return x * y; }
 
 #[inline(always)]
-pub fn div(x: f32, y: f32) -> f32 { return x / y; }
+pub fn quot(x: f32, y: f32) -> f32 { return x / y; }
 
 #[inline(always)]
 pub fn rem(x: f32, y: f32) -> f32 { return x % y; }
@@ -279,11 +279,16 @@ impl Mul<f32,f32> for f32 {
     fn mul(&self, other: &f32) -> f32 { *self * *other }
 }
 
-#[cfg(notest)]
+#[cfg(stage0,notest)]
 impl Div<f32,f32> for f32 {
     #[inline(always)]
     fn div(&self, other: &f32) -> f32 { *self / *other }
 }
+#[cfg(not(stage0),notest)]
+impl Quot<f32,f32> for f32 {
+    #[inline(always)]
+    fn quot(&self, other: &f32) -> f32 { *self / *other }
+}
 
 #[cfg(stage0,notest)]
 impl Modulo<f32,f32> for f32 {

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

@@ -149,7 +149,7 @@ pub fn sub(x: f64, y: f64) -> f64 { return x - y; }
 pub fn mul(x: f64, y: f64) -> f64 { return x * y; }
 
 #[inline(always)]
-pub fn div(x: f64, y: f64) -> f64 { return x / y; }
+pub fn quot(x: f64, y: f64) -> f64 { return x / y; }
 
 #[inline(always)]
 pub fn rem(x: f64, y: f64) -> f64 { return x % y; }
@@ -296,10 +296,15 @@ impl Sub<f64,f64> for f64 {
 impl Mul<f64,f64> for f64 {
     fn mul(&self, other: &f64) -> f64 { *self * *other }
 }
-#[cfg(notest)]
+#[cfg(stage0,notest)]
 impl Div<f64,f64> for f64 {
     fn div(&self, other: &f64) -> f64 { *self / *other }
 }
+#[cfg(not(stage0),notest)]
+impl Quot<f64,f64> for f64 {
+    #[inline(always)]
+    fn quot(&self, other: &f64) -> f64 { *self / *other }
+}
 #[cfg(stage0,notest)]
 impl Modulo<f64,f64> for f64 {
     fn modulo(&self, other: &f64) -> f64 { *self % *other }

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

@@ -25,7 +25,7 @@ use libc::c_int;
 use num::{Zero, One, strconv};
 use prelude::*;
 
-pub use f64::{add, sub, mul, div, rem, lt, le, eq, ne, ge, gt};
+pub use f64::{add, sub, mul, quot, rem, lt, le, eq, ne, ge, gt};
 pub use f64::logarithm;
 pub use f64::{acos, asin, atan2, cbrt, ceil, copysign, cosh, floor};
 pub use f64::{erf, erfc, exp, expm1, exp2, abs_sub};
@@ -692,12 +692,16 @@ impl Mul<float,float> for float {
     fn mul(&self, other: &float) -> float { *self * *other }
 }
 
-#[cfg(notest)]
+#[cfg(stage0,notest)]
 impl Div<float,float> for float {
     #[inline(always)]
     fn div(&self, other: &float) -> float { *self / *other }
 }
-
+#[cfg(not(stage0),notest)]
+impl Quot<float,float> for float {
+    #[inline(always)]
+    fn quot(&self, other: &float) -> float { *self / *other }
+}
 #[cfg(stage0,notest)]
 impl Modulo<float,float> for float {
     #[inline(always)]