---

yaml
---
r: 64826
b: refs/heads/snap-stage3
c: 11aad20
h: refs/heads/master
v: v3

Author: blake2-ppc

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: fddb35e988384c7aa5d9aaf96c1e075bede7a188
+refs/heads/snap-stage3: 11aad20cf879f508a339c2af2bad901446f4fb3a
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/doc/tutorial.md

@@ -309,7 +309,7 @@ was taken.
 
 In short, everything that's not a declaration (declarations are `let` for
 variables; `fn` for functions; and any top-level named items such as
-[traits](#traits), [enum types](#enums), and static items) is an
+[traits](#traits), [enum types](#enums), and [constants](#constants)) is an
 expression, including function bodies.
 
 ~~~~
@@ -992,7 +992,7 @@ task-local garbage collector. It will be destroyed at some point after there
 are no references left to the box, no later than the end of the task. Managed
 boxes lack an owner, so they start a new ownership tree and don't inherit
 mutability. They do own the contained object, and mutability is defined by the
-type of the managed box (`@` or `@mut`). An object containing a managed box is
+type of the shared box (`@` or `@mut`). An object containing a managed box is
 not `Owned`, and can't be sent between tasks.
 
 ~~~~
@@ -1089,8 +1089,10 @@ we might like to compute the distance between `on_the_stack` and
 to define a function that takes two arguments of type point—that is,
 it takes the points by value. But this will cause the points to be
 copied when we call the function. For points, this is probably not so
-bad, but often copies are expensive. So we’d like to define a function
-that takes the points by pointer. We can use borrowed pointers to do this:
+bad, but often copies are expensive or, worse, if there are mutable
+fields, they can change the semantics of your program. So we’d like to
+define a function that takes the points by pointer. We can use
+borrowed pointers to do this:
 
 ~~~
 # struct Point { x: float, y: float }
@@ -1373,7 +1375,7 @@ let exchange_crayons: ~str = ~"Black, BlizzardBlue, Blue";
 ~~~
 
 Both vectors and strings support a number of useful
-[methods](#methods), defined in [`std::vec`]
+[methods](#functions-and-methods), defined in [`std::vec`]
 and [`std::str`]. Here are some examples.
 
 [`std::vec`]: std/vec.html
@@ -1928,7 +1930,7 @@ that implements a trait includes the name of the trait at the start of
 the definition, as in the following impls of `Printable` for `int`
 and `~str`.
 
-[impls]: #methods
+[impls]: #functions-and-methods
 
 ~~~~
 # trait Printable { fn print(&self); }

branches/snap-stage3/src/compiletest/runtest.rs

@@ -22,7 +22,6 @@ use util::logv;
 
 use std::io;
 use std::os;
-use std::str;
 use std::uint;
 use std::vec;
 
@@ -356,30 +355,6 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
         fmt!("%s:%u:", testfile.to_str(), ee.line)
     }).collect::<~[~str]>();
 
-    fn to_lower( s : &str ) -> ~str {
-        let i = s.iter();
-        let c : ~[char] = i.transform( |c| {
-            if c.is_ascii() {
-                c.to_ascii().to_lower().to_char()
-            } else {
-                c
-            }
-        } ).collect();
-        str::from_chars( c )
-    }
-
-    #[cfg(target_os = "win32")]
-    fn prefix_matches( line : &str, prefix : &str ) -> bool {
-        to_lower(line).starts_with( to_lower(prefix) )
-    }
-
-    #[cfg(target_os = "linux")]
-    #[cfg(target_os = "macos")]
-    #[cfg(target_os = "freebsd")]
-    fn prefix_matches( line : &str, prefix : &str ) -> bool {
-        line.starts_with( prefix )
-    }
-
     // Scan and extract our error/warning messages,
     // which look like:
     //    filename:line1:col1: line2:col2: *error:* msg
@@ -392,7 +367,7 @@ fn check_expected_errors(expected_errors: ~[errors::ExpectedError],
             if !found_flags[i] {
                 debug!("prefix=%s ee.kind=%s ee.msg=%s line=%s",
                        prefixes[i], ee.kind, ee.msg, line);
-                if (prefix_matches(line, prefixes[i]) &&
+                if (line.starts_with(prefixes[i]) &&
                     line.contains(ee.kind) &&
                     line.contains(ee.msg)) {
                     found_flags[i] = true;

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

@@ -97,6 +97,26 @@ clone_impl!(())
 clone_impl!(bool)
 clone_impl!(char)
 
+macro_rules! extern_fn_clone(
+    ($($A:ident),*) => (
+        impl<$($A,)* ReturnType> Clone for extern "Rust" fn($($A),*) -> ReturnType {
+            /// Return a copy of a function pointer
+            #[inline]
+            fn clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
+        }
+    )
+)
+
+extern_fn_clone!()
+extern_fn_clone!(A)
+extern_fn_clone!(A, B)
+extern_fn_clone!(A, B, C)
+extern_fn_clone!(A, B, C, D)
+extern_fn_clone!(A, B, C, D, E)
+extern_fn_clone!(A, B, C, D, E, F)
+extern_fn_clone!(A, B, C, D, E, F, G)
+extern_fn_clone!(A, B, C, D, E, F, G, H)
+
 /// A trait distinct from `Clone` which represents "deep copies" of things like
 /// managed boxes which would otherwise not be copied.
 pub trait DeepClone {
@@ -157,6 +177,26 @@ deep_clone_impl!(())
 deep_clone_impl!(bool)
 deep_clone_impl!(char)
 
+macro_rules! extern_fn_deep_clone(
+    ($($A:ident),*) => (
+        impl<$($A,)* ReturnType> DeepClone for extern "Rust" fn($($A),*) -> ReturnType {
+            /// Return a copy of a function pointer
+            #[inline]
+            fn deep_clone(&self) -> extern "Rust" fn($($A),*) -> ReturnType { *self }
+        }
+    )
+)
+
+extern_fn_deep_clone!()
+extern_fn_deep_clone!(A)
+extern_fn_deep_clone!(A, B)
+extern_fn_deep_clone!(A, B, C)
+extern_fn_deep_clone!(A, B, C, D)
+extern_fn_deep_clone!(A, B, C, D, E)
+extern_fn_deep_clone!(A, B, C, D, E, F)
+extern_fn_deep_clone!(A, B, C, D, E, F, G)
+extern_fn_deep_clone!(A, B, C, D, E, F, G, H)
+
 #[test]
 fn test_owned_clone() {
     let a = ~5i;
@@ -195,3 +235,21 @@ fn test_borrowed_clone() {
     let z: &int = (&y).clone();
     assert_eq!(*z, 5);
 }
+
+#[test]
+fn test_extern_fn_clone() {
+    trait Empty {}
+    impl Empty for int {}
+
+    fn test_fn_a() -> float { 1.0 }
+    fn test_fn_b<T: Empty>(x: T) -> T { x }
+    fn test_fn_c(_: int, _: float, _: ~[int], _: int, _: int, _: int) {}
+
+    let _ = test_fn_a.clone();
+    let _ = test_fn_b::<int>.clone();
+    let _ = test_fn_c.clone();
+
+    let _ = test_fn_a.deep_clone();
+    let _ = test_fn_b::<int>.deep_clone();
+    let _ = test_fn_c.deep_clone();
+}

branches/snap-stage3/src/libstd/unstable/extfmt.rs

@@ -114,7 +114,6 @@ pub mod ct {
         TyHex(Caseness),
         TyOctal,
         TyFloat,
-        TyPointer,
         TyPoly,
     }
 
@@ -326,7 +325,6 @@ pub mod ct {
             't' => TyBits,
             'o' => TyOctal,
             'f' => TyFloat,
-            'p' => TyPointer,
             '?' => TyPoly,
             _ => err(fmt!("unknown type in conversion: %c", s.char_at(i)))
         };
@@ -436,7 +434,6 @@ pub mod ct {
         assert!(test("t", TyBits));
         assert!(test("x", TyHex(CaseLower)));
         assert!(test("X", TyHex(CaseUpper)));
-        assert!(test("p", TyPointer));
         assert!(test("?", TyPoly));
     }
 
@@ -576,10 +573,6 @@ pub mod rt {
         } else { None };
         pad(cv, s, head, PadFloat, buf);
     }
-    pub fn conv_pointer<T>(cv: Conv, ptr: *T, buf: &mut ~str) {
-        let s = ~"0x" + uint_to_str_prec(ptr as uint, 16, 1u);
-        pad(cv, s, None, PadNozero, buf);
-    }
     pub fn conv_poly<T>(cv: Conv, v: &T, buf: &mut ~str) {
         let s = sys::log_str(v);
         conv_str(cv, s, buf);

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

@@ -191,7 +191,6 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
             TyChar => ("char", arg),
             TyBits | TyOctal | TyHex(_) | TyInt(Unsigned) => ("uint", arg),
             TyFloat => ("float", arg),
-            TyPointer => ("pointer", arg),
             TyPoly => ("poly", cx.expr_addr_of(sp, arg))
         };
         return make_conv_call(cx, arg.span, name, cnv, actual_arg,
@@ -243,7 +242,6 @@ fn pieces_to_expr(cx: @ExtCtxt, sp: span,
           },
           TyOctal => debug!("type: octal"),
           TyFloat => debug!("type: float"),
-          TyPointer => debug!("type: pointer"),
           TyPoly => debug!("type: poly")
         }
     }

branches/snap-stage3/src/test/run-pass/syntax-extension-fmt.rs

@@ -32,7 +32,6 @@ pub fn main() {
     part6();
     percent();
     more_floats();
-    pointer();
 }
 
 fn part1() {
@@ -264,13 +263,3 @@ fn more_floats() {
     assert_eq!(~"7.0000", fmt!("%.4f", 6.999999999));
     assert_eq!(~"3.141590000", fmt!("%.9f", 3.14159));
 }
-
-fn pointer() {
-    for 10.times {
-        let x: uint = ::std::rand::random();
-        assert_eq!(fmt!("%p", x as *uint), fmt!("0x%x", x));
-    }
-
-    let i = &1;
-    assert_eq!(fmt!("%p", i), fmt!("0x%x", i as *uint as uint));
-}