---

yaml
---
r: 105405
b: refs/heads/master
c: 5026d11
h: refs/heads/master
i:
  105403: 258a904
v: v3

Author: mcpherrinm

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 6fa72dfe48c8db04562f4d3ab640cb90804af69b
+refs/heads/master: 5026d114a0bbe27f2052af9fbadebacac80e1955
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b8601a3d8b91ad3b653d143307611f2f5c75617e
 refs/heads/try: db814977d07bd798feb24f6b74c00800ef458a13

trunk/src/libgetopts/lib.rs

@@ -98,34 +98,27 @@ use std::vec;
 
 /// Name of an option. Either a string or a single char.
 #[deriving(Clone, Eq)]
+#[allow(missing_doc)]
 pub enum Name {
-    /// A string representing the long name of an option.
-    /// For example: "help"
     Long(~str),
-    /// A char representing the short name of an option.
-    /// For example: 'h'
     Short(char),
 }
 
 /// Describes whether an option has an argument.
 #[deriving(Clone, Eq)]
+#[allow(missing_doc)]
 pub enum HasArg {
-    /// The option requires an argument.
     Yes,
-    /// The option is just a flag, therefore no argument.
     No,
-    /// The option argument is optional and it could or not exist.
     Maybe,
 }
 
 /// Describes how often an option may occur.
 #[deriving(Clone, Eq)]
+#[allow(missing_doc)]
 pub enum Occur {
-    /// The option occurs once.
     Req,
-    /// The option could or not occur.
     Optional,
-    /// The option occurs once or multiple times.
     Multi,
 }
 
@@ -183,16 +176,12 @@ pub struct Matches {
 /// expected format. Call the `to_err_msg` method to retrieve the
 /// error as a string.
 #[deriving(Clone, Eq, Show)]
+#[allow(missing_doc)]
 pub enum Fail_ {
-    /// The option requires an argument but none was passed.
     ArgumentMissing(~str),
-    /// The passed option is not declared among the possible options.
     UnrecognizedOption(~str),
-    /// A required option is not present.
     OptionMissing(~str),
-    /// A single occurence option is being used multiple times.
     OptionDuplicated(~str),
-    /// There's an argument being passed to a non-argument option.
     UnexpectedArgument(~str),
 }
 

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -2317,13 +2317,11 @@ fn check_expr_with_unifier(fcx: @FnCtxt,
                 fcx.type_error_message(
                     expr.span,
                     |actual| {
-                        format!("attempted to take value of method `{}` on type `{}`",
+                        format!("attempted to take value of method `{}` on type `{}` \
+                                 (try writing an anonymous function)",
                                 token::get_name(field), actual)
                     },
                     expr_t, None);
-
-                tcx.sess.span_note(expr.span,
-                    "maybe a missing `()` to call it? If not, try an anonymous function.");
             }
 
             None => {

trunk/src/libstd/mem.rs

@@ -99,32 +99,127 @@ pub unsafe fn move_val_init<T>(dst: &mut T, src: T) {
     intrinsics::move_val_init(dst, src)
 }
 
+/// Convert an i16 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_le16(x: i16) -> i16 { x }
+
+/// Convert an i16 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+
+/// Convert an i32 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_le32(x: i32) -> i32 { x }
+
+/// Convert an i32 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+
+/// Convert an i64 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_le64(x: i64) -> i64 { x }
+
+/// Convert an i64 to little endian from the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
 
+
+/// Convert an i16 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+
+/// Convert an i16 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_be16(x: i16) -> i16 { x }
+
+/// Convert an i32 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+
+/// Convert an i32 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_be32(x: i32) -> i32 { x }
+
+/// Convert an i64 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn to_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+
+/// Convert an i64 to big endian from the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn to_be64(x: i64) -> i64 { x }
 
+
+/// Convert an i16 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_le16(x: i16) -> i16 { x }
+
+/// Convert an i16 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_le16(x: i16) -> i16 { unsafe { bswap16(x) } }
+
+/// Convert an i32 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_le32(x: i32) -> i32 { x }
+
+/// Convert an i32 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_le32(x: i32) -> i32 { unsafe { bswap32(x) } }
+
+/// Convert an i64 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_le64(x: i64) -> i64 { x }
+
+/// Convert an i64 from little endian to the target's endianness.
+///
+/// On little endian, this is a no-op.  On big endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_le64(x: i64) -> i64 { unsafe { bswap64(x) } }
 
+
+/// Convert an i16 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_be16(x: i16) -> i16 { unsafe { bswap16(x) } }
+
+/// Convert an i16 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_be16(x: i16) -> i16 { x }
+
+/// Convert an i32 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_be32(x: i32) -> i32 { unsafe { bswap32(x) } }
+
+/// Convert an i32 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_be32(x: i32) -> i32 { x }
+
+/// Convert an i64 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "little")] #[inline] pub fn from_be64(x: i64) -> i64 { unsafe { bswap64(x) } }
+
+/// Convert an i64 from big endian to the target's endianness.
+///
+/// On big endian, this is a no-op.  On little endian, the bytes are swapped.
 #[cfg(target_endian = "big")]    #[inline] pub fn from_be64(x: i64) -> i64 { x }
 
 

trunk/src/libstd/option.rs

@@ -311,10 +311,10 @@ impl<T> Option<T> {
     /// Fails if the value equals `None`.
     #[inline]
     pub fn take_unwrap(&mut self) -> T {
-        match self.take() {
-            Some(x) => x,
-            None => fail!("called `Option::take_unwrap()` on a `None` value")
+        if self.is_none() {
+            fail!("called `Option::take_unwrap()` on a `None` value")
         }
+        self.take().unwrap()
     }
 
     /// Gets an immutable reference to the value inside an option.

trunk/src/libtime/lib.rs

@@ -187,51 +187,20 @@ pub fn tzset() {
     }
 }
 
-/// Holds a calendar date and time broken down into its components (year, month, day, and so on),
-/// also called a broken-down time value.
 #[deriving(Clone, Eq, Encodable, Decodable, Show)]
 pub struct Tm {
-    /// Seconds after the minute – [0, 60]
-    tm_sec: i32,
-
-    /// Minutes after the hour – [0, 59]
-    tm_min: i32,
-
-    /// Hours after midnight – [0, 23]
-    tm_hour: i32,
-
-    /// Day of the month – [1, 31]
-    tm_mday: i32,
-
-    /// Months since January – [0, 11]
-    tm_mon: i32,
-
-    /// Years since 1900
-    tm_year: i32,
-
-    /// Days since Sunday – [0, 6]. 0 = Sunday, 1 = Monday, …, 6 = Saturday.
-    tm_wday: i32,
-
-    /// Days since January 1 – [0, 365]
-    tm_yday: i32,
-
-    /// Daylight Saving Time flag.
-    ///
-    /// This value is positive if Daylight Saving Time is in effect, zero if Daylight Saving Time
-    /// is not in effect, and negative if this information is not available.
-    tm_isdst: i32,
-
-    /// Identifies the time zone that was used to compute this broken-down time value, including any
-    /// adjustment for Daylight Saving Time. This is the number of seconds east of UTC. For example,
-    /// for U.S. Pacific Daylight Time, the value is -7*60*60 = -25200.
-    tm_gmtoff: i32,
-
-    /// Abbreviated name for the time zone that was used to compute this broken-down time value.
-    /// For example, U.S. Pacific Daylight Time is "PDT".
-    tm_zone: ~str,
-
-    /// Nanoseconds after the second – [0, 10<sup>9</sup> - 1]
-    tm_nsec: i32,
+    tm_sec: i32, // seconds after the minute ~[0-60]
+    tm_min: i32, // minutes after the hour ~[0-59]
+    tm_hour: i32, // hours after midnight ~[0-23]
+    tm_mday: i32, // days of the month ~[1-31]
+    tm_mon: i32, // months since January ~[0-11]
+    tm_year: i32, // years since 1900
+    tm_wday: i32, // days since Sunday ~[0-6]
+    tm_yday: i32, // days since January 1 ~[0-365]
+    tm_isdst: i32, // Daylight Savings Time flag
+    tm_gmtoff: i32, // offset from UTC in seconds
+    tm_zone: ~str, // timezone abbreviation
+    tm_nsec: i32, // nanoseconds
 }
 
 pub fn empty_tm() -> Tm {

trunk/src/test/compile-fail/method-missing-call.rs

@@ -13,10 +13,6 @@
 // ignore-android needs extra network permissions
 // exec-env:RUST_LOG=debug
 
-#[feature(phase)];
-#[phase(syntax, link)]
-extern crate log;
-
 use std::libc;
 use std::io::net::ip::{Ipv4Addr, SocketAddr};
 use std::io::net::tcp::{TcpListener, TcpStream};