---

yaml
---
r: 64292
b: refs/heads/snap-stage3
c: 48bfb90
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 9735f339fe8397bdc55495ef5875982779461cd2
+refs/heads/snap-stage3: 48bfb90865722cf9ffa62a611b3dd41ba8f3d2e4
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/mk/dist.mk

@@ -19,9 +19,7 @@ PKG_FILES := \
     $(S)LICENSE-APACHE                         \
     $(S)LICENSE-MIT                            \
     $(S)AUTHORS.txt                            \
-    $(S)CONTRIBUTING.md                        \
     $(S)README.md                              \
-    $(S)RELEASES.txt                           \
     $(S)configure $(S)Makefile.in              \
     $(S)man                                    \
     $(S)doc                                    \

branches/snap-stage3/src/libstd/cmp.rs

@@ -157,19 +157,20 @@ pub fn lexical_ordering(o1: Ordering, o2: Ordering) -> Ordering {
 /**
 * Trait for values that can be compared for a sort-order.
 *
-* Eventually this may be simplified to only require
-* an `le` method, with the others generated from
-* default implementations. However it should remain
-* possible to implement the others separately, for
-* compatibility with floating-point NaN semantics
+* Ord only requires implementation of the `lt` method,
+* with the others generated from default implementations.
+*
+* However it remains possible to implement the others separately,
+* for compatibility with floating-point NaN semantics
 * (cf. IEEE 754-2008 section 5.11).
 */
+#[allow(default_methods)] // NOTE: Remove when allowed in stage0
 #[lang="ord"]
 pub trait Ord {
     fn lt(&self, other: &Self) -> bool;
-    fn le(&self, other: &Self) -> bool;
-    fn ge(&self, other: &Self) -> bool;
-    fn gt(&self, other: &Self) -> bool;
+    fn le(&self, other: &Self) -> bool { !other.lt(self) }
+    fn gt(&self, other: &Self) -> bool {  other.lt(self) }
+    fn ge(&self, other: &Self) -> bool { !self.lt(other) }
 }
 
 /// The equivalence relation. Two values may be equivalent even if they are

branches/snap-stage3/src/libsyntax/ext/expand.rs

@@ -643,6 +643,18 @@ pub fn core_macros() -> @str {
             $(if $pred $body)else+
         );
     )
+
+    macro_rules! print(
+        ($( $arg:expr),+) => ( {
+            print(fmt!($($arg),+));
+        } )
+    )
+
+    macro_rules! println(
+        ($( $arg:expr),+) => ( {
+            println(fmt!($($arg),+));
+        } )
+    )
 }";
 }
 

branches/snap-stage3/src/test/compile-fail/issue-3344.rs

@@ -9,8 +9,7 @@
 // except according to those terms.
 
 struct thing(uint);
-impl Ord for thing { //~ ERROR missing method `gt`
-    fn lt(&self, other: &thing) -> bool { **self < **other }
+impl Ord for thing { //~ ERROR missing method `lt`
     fn le(&self, other: &thing) -> bool { **self < **other }
     fn ge(&self, other: &thing) -> bool { **self < **other }
 }

branches/snap-stage3/src/test/run-pass/cmp-default.rs

@@ -0,0 +1,43 @@
+// Copyright 2012 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.
+
+// Test default methods in Ord
+//
+struct Int(int);
+
+impl Ord for Int {
+    fn lt(&self, other: &Int) -> bool {
+        **self < **other
+    }
+}
+
+struct RevInt(int);
+
+impl Ord for RevInt {
+    fn lt(&self, other: &RevInt) -> bool {
+        **self > **other
+    }
+}
+
+pub fn main() {
+    assert!(Int(2) >  Int(1));
+    assert!(Int(2) >= Int(1));
+    assert!(Int(1) >= Int(1));
+    assert!(Int(1) <  Int(2));
+    assert!(Int(1) <= Int(2));
+    assert!(Int(1) <= Int(1));
+
+    assert!(RevInt(2) <  RevInt(1));
+    assert!(RevInt(2) <= RevInt(1));
+    assert!(RevInt(1) <= RevInt(1));
+    assert!(RevInt(1) >  RevInt(2));
+    assert!(RevInt(1) >= RevInt(2));
+    assert!(RevInt(1) >= RevInt(1));
+}