---

yaml
---
r: 105407
b: refs/heads/master
c: 5db7f7e
h: refs/heads/master
i:
  105405: 4552796
  105403: 258a904
  105399: 4064360
  105391: 8810cf8
  105375: 954b81b
  105343: 29db2b1
v: v3

Author: cadencemarseille

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: eb68beec4b809c1e091ce678a2c18347701497c2
+refs/heads/master: 5db7f7ed2413476e2006af6068d1b3a53e00db38
 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,127 +99,32 @@ 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/libstd/vec_ng.rs

@@ -415,8 +415,7 @@ impl<T> Vec<T> {
         unsafe { // infallible
             // The spot to put the new value
             {
-                let slice = self.as_mut_slice();
-                let p = slice.as_mut_ptr().offset(index as int);
+                let p = self.as_mut_ptr().offset(index as int);
                 // Shift everything over to make space. (Duplicating the
                 // `index`th element into two consecutive places.)
                 ptr::copy_memory(p.offset(1), &*p, len - index);
@@ -434,9 +433,8 @@ impl<T> Vec<T> {
             unsafe { // infallible
                 let ret;
                 {
-                    let slice = self.as_mut_slice();
                     // the place we are taking from.
-                    let ptr = slice.as_mut_ptr().offset(index as int);
+                    let ptr = self.as_mut_ptr().offset(index as int);
                     // copy it out, unsafely having a copy of the value on
                     // the stack and in the vector at the same time.
                     ret = Some(ptr::read(ptr as *T));
@@ -499,6 +497,11 @@ impl<T> Vec<T> {
     pub fn as_ptr(&self) -> *T {
         self.as_slice().as_ptr()
     }
+
+    #[inline]
+    pub fn as_mut_ptr(&mut self) -> *mut T {
+        self.as_mut_slice().as_mut_ptr()
+    }
 }
 
 impl<T> Mutable for Vec<T> {

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};