---

yaml
---
r: 64183
b: refs/heads/snap-stage3
c: 663a959
h: refs/heads/master
i:
  64181: f608e21
  64179: 9e35e02
  64175: b3c50db
v: v3

Author: kevinmehall

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 294999c3508ef4cbc2d221f531a6255c82fb95d3
+refs/heads/snap-stage3: 663a9597b24f841f44e560e2478225353dbcec30
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

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

@@ -186,6 +186,13 @@ pub mod types {
     // Standard types that are opaque or common, so are not per-target.
     pub mod common {
         pub mod c95 {
+            /**
+            Type used to construct void pointers for use with C.
+
+            This type is only useful as a pointer target. Do not use it as a
+            return type for FFI functions which have the `void` return type in
+            C. Use the unit type `()` or omit the return type instead.
+            */
             pub enum c_void {}
             pub enum FILE {}
             pub enum fpos_t {}

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

@@ -15,8 +15,6 @@ use option::{Option, Some, None};
 use sys;
 use unstable::intrinsics;
 use util::swap;
-use ops::{Add,Sub};
-use num::Int;
 
 #[cfg(not(test))] use cmp::{Eq, Ord};
 use uint;
@@ -386,46 +384,6 @@ impl<T> Ord for *const T {
     }
 }
 
-#[cfg(not(test))]
-impl<T, I: Int> Add<I, *T> for *T {
-    /// Add an integer value to a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn add(&self, rhs: &I) -> *T {
-        self.offset(rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Sub<I, *T> for *T {
-    /// Subtract an integer value from a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn sub(&self, rhs: &I) -> *T {
-        self.offset(-rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Add<I, *mut T> for *mut T {
-    /// Add an integer value to a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn add(&self, rhs: &I) -> *mut T {
-        self.offset(rhs.to_int() as uint)
-    }
-}
-
-#[cfg(not(test))]
-impl<T, I: Int> Sub<I, *mut T> for *mut T {
-    /// Subtract an integer value from a pointer to get an offset pointer.
-    /// Is calculated according to the size of the type pointed to.
-    #[inline]
-    pub fn sub(&self, rhs: &I) -> *mut T {
-        self.offset(-rhs.to_int() as uint)
-    }
-}
-
 #[cfg(test)]
 pub mod ptr_tests {
     use super::*;
@@ -543,60 +501,6 @@ pub mod ptr_tests {
         }
     }
 
-    #[test]
-    fn test_ptr_addition() {
-        use vec::raw::*;
-
-        unsafe {
-            let xs = ~[5, ..16];
-            let mut ptr = to_ptr(xs);
-            let end = ptr + 16;
-
-            while ptr < end {
-                assert_eq!(*ptr, 5);
-                ptr = ptr + 1u;
-            }
-
-            let mut xs_mut = xs.clone();
-            let mut m_ptr = to_mut_ptr(xs_mut);
-            let m_end = m_ptr + 16i16;
-
-            while m_ptr < m_end {
-                *m_ptr += 5;
-                m_ptr = m_ptr + 1u8;
-            }
-
-            assert_eq!(xs_mut, ~[10, ..16]);
-        }
-    }
-
-    #[test]
-    fn test_ptr_subtraction() {
-        use vec::raw::*;
-
-        unsafe {
-            let xs = ~[0,1,2,3,4,5,6,7,8,9];
-            let mut idx = 9i8;
-            let ptr = to_ptr(xs);
-
-            while idx >= 0i8 {
-                assert_eq!(*(ptr + idx), idx as int);
-                idx = idx - 1i8;
-            }
-
-            let mut xs_mut = xs.clone();
-            let mut m_start = to_mut_ptr(xs_mut);
-            let mut m_ptr = m_start + 9u32;
-
-            while m_ptr >= m_start {
-                *m_ptr += *m_ptr;
-                m_ptr = m_ptr - 1i8;
-            }
-
-            assert_eq!(xs_mut, ~[0,2,4,6,8,10,12,14,16,18]);
-        }
-    }
-
     #[test]
     fn test_ptr_array_each_with_len() {
         unsafe {

branches/snap-stage3/src/libsyntax/parse/parser.rs

@@ -1074,10 +1074,9 @@ impl Parser {
     // This version of parse arg doesn't necessarily require
     // identifier names.
     pub fn parse_arg_general(&self, require_name: bool) -> arg {
-        let mut is_mutbl = false;
+        let mut is_mutbl = self.eat_keyword(keywords::Mut);
         let pat = if require_name || self.is_named_argument() {
             self.parse_arg_mode();
-            is_mutbl = self.eat_keyword(keywords::Mut);
             let pat = self.parse_pat();
 
             if is_mutbl && !ast_util::pat_is_ident(pat) {

branches/snap-stage3/src/test/run-pass/traits-default-method-mut.rs

@@ -0,0 +1,17 @@
+// Copyright 2013 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.
+
+#[allow(default_methods)];
+
+trait Foo {
+    fn foo(&self, mut v: int) { v = 1; }
+}
+
+fn main() {}