---

yaml
---
r: 137566
b: refs/heads/master
c: d569dfe
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 98a0f9166c38d9a761a840de15a668ea001c9e9c
+refs/heads/master: d569dfe37eac393509351c28db01e50e0ca323c2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: cd53dac86b43e0b46f06ab265b71526242a2fc5e

trunk/src/doc/guide-macros.md

@@ -87,7 +87,7 @@ forbidden.
 
 Otherwise, the invocation syntax is free-form.
 
-To take as an argument a fragment of Rust code, write `$` followed by a name
+To take a fragment of Rust code as an argument, write `$` followed by a name
  (for use on the right-hand side), followed by a `:`, followed by a *fragment
  specifier*. The fragment specifier denotes the sort of fragment to match. The
  most common fragment specifiers are:

trunk/src/doc/guide.md

@@ -5212,8 +5212,8 @@ We can check this out using a special flag to `rustc`. This code, in a file
 
 ```{rust}
 fn main() {
-    let x = "Hello";
-    println!("x is: {:s}", x);
+    let x = 5i;
+    println!("x is: {}", x);
 }
 ```
 
@@ -5225,32 +5225,19 @@ give us this huge result:
 #![no_std]
 #![feature(globs)]
 #[phase(plugin, link)]
-extern crate std = "std";
-extern crate rt = "native";
+extern crate "std" as std;
+extern crate "native" as rt;
+#[prelude_import]
 use std::prelude::*;
 fn main() {
-    let x = "Hello";
+    let x = 5i;
     match (&x,) {
         (__arg0,) => {
             #[inline]
             #[allow(dead_code)]
-            static __STATIC_FMTSTR: [::std::fmt::rt::Piece<'static>, ..2u] =
-                [::std::fmt::rt::String("x is: "),
-                 ::std::fmt::rt::Argument(::std::fmt::rt::Argument{position:
-                                                                       ::std::fmt::rt::ArgumentNext,
-                                                                   format:
-                                                                       ::std::fmt::rt::FormatSpec{fill:
-                                                                                                      ' ',
-                                                                                                  align:
-                                                                                                      ::std::fmt::rt::AlignUnknown,
-                                                                                                  flags:
-                                                                                                      0u,
-                                                                                                  precision:
-                                                                                                      ::std::fmt::rt::CountImplied,
-                                                                                                  width:
-                                                                                                      ::std::fmt::rt::CountImplied,},})];
+            static __STATIC_FMTSTR: [&'static str, ..1u] = ["x is: "];
             let __args_vec =
-                &[::std::fmt::argument(::std::fmt::secret_string, __arg0)];
+                &[::std::fmt::argument(::std::fmt::secret_show, __arg0)];
             let __args =
                 unsafe {
                     ::std::fmt::Arguments::new(__STATIC_FMTSTR, __args_vec)
@@ -5261,45 +5248,16 @@ fn main() {
 }
 ```
 
-Intense. Here's a trimmed down version that's a bit easier to read:
-
-```{rust,ignore}
-fn main() {
-    let x = 5i;
-    match (&x,) {
-        (__arg0,) => {
-            static __STATIC_FMTSTR:  =
-                [String("x is: "),
-                 Argument(Argument {
-                    position: ArgumentNext,
-                    format: FormatSpec {
-                        fill: ' ',
-                        align: AlignUnknown,
-                        flags: 0u,
-                        precision: CountImplied,
-                        width: CountImplied,
-                    },
-                },
-               ];
-            let __args_vec = &[argument(secret_string, __arg0)];
-            let __args = unsafe { Arguments::new(__STATIC_FMTSTR, __args_vec) };
-
-            println_args(&__args)
-        }
-    };
-}
-```
-
 Whew! This isn't too terrible. You can see that we still `let x = 5i`,
 but then things get a little bit hairy. Three more bindings get set: a
 static format string, an argument vector, and the arguments. We then
 invoke the `println_args` function with the generated arguments.
 
-This is the code (well, the full version) that Rust actually compiles. You can
-see all of the extra information that's here. We get all of the type safety and
-options that it provides, but at compile time, and without needing to type all
-of this out. This is how macros are powerful. Without them, you would need to
-type all of this by hand to get a type checked `println`.
+This is the code that Rust actually compiles. You can see all of the extra
+information that's here. We get all of the type safety and options that it
+provides, but at compile time, and without needing to type all of this out.
+This is how macros are powerful. Without them, you would need to type all of
+this by hand to get a type checked `println`.
 
 For more on macros, please consult [the Macros Guide](guide-macros.html).
 Macros are a very advanced and still slightly experimental feature, but don't

trunk/src/doc/reference.md

@@ -187,6 +187,8 @@ grammar as double-quoted strings. Other tokens have exact rules given.
 
 The keywords are the following strings, organized by first letter:
 
+<div id="keywords">
+|          |        |        |       |
 |----------|--------|--------|-------|
 | as       |        |        |       |
 |----------|--------|--------|-------|
@@ -216,6 +218,7 @@ The keywords are the following strings, organized by first letter:
 |----------|--------|--------|-------|
 | while    |        |        |       |
 |----------|--------|--------|-------|
+</div>
 
 Each of these keywords has special meaning in its grammar, and all of them are
 excluded from the `ident` rule.

trunk/src/doc/rust.css

@@ -392,3 +392,5 @@ pre.rust { position: relative; }
         background-color: #fff !important;
     }
 }
+
+#keywords table td { border: none; }

trunk/src/etc/vim/syntax/rust.vim

@@ -54,7 +54,7 @@ syn match rustMacroRepeatCount ".\?[*+]" contained
 syn match rustMacroVariable "$\w\+"
 
 " Reserved (but not yet used) keywords {{{2
-syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield
+syn keyword   rustReservedKeyword alignof be do offsetof priv pure sizeof typeof unsized yield abstract final override
 
 " Built-in types {{{2
 syn keyword   rustType        int uint float char bool u8 u16 u32 u64 f32

trunk/src/libcollections/str.rs

@@ -75,7 +75,7 @@ use vec::Vec;
 pub use core::str::{from_utf8, CharEq, Chars, CharOffsets};
 pub use core::str::{Bytes, CharSplits};
 pub use core::str::{CharSplitsN, AnyLines, MatchIndices, StrSplits};
-pub use core::str::{eq_slice, is_utf8, is_utf16, Utf16Items};
+pub use core::str::{Utf16CodeUnits, eq_slice, is_utf8, is_utf16, Utf16Items};
 pub use core::str::{Utf16Item, ScalarValue, LoneSurrogate, utf16_items};
 pub use core::str::{truncate_utf16_at_nul, utf8_char_width, CharRange};
 pub use core::str::{Str, StrSlice};

trunk/src/libcollections/string.rs

@@ -28,7 +28,7 @@ use slice::CloneableVector;
 use str;
 use str::{CharRange, StrAllocating, MaybeOwned, Owned};
 use str::Slice as MaybeOwnedSlice; // So many `Slice`s...
-use vec::Vec;
+use vec::{DerefVec, Vec, as_vec};
 
 /// A growable string stored as a UTF-8 encoded buffer.
 #[deriving(Clone, PartialEq, PartialOrd, Eq, Ord)]
@@ -973,6 +973,24 @@ impl ops::Slice<uint, str> for String {
     }
 }
 
+/// Wrapper type providing a `&String` reference via `Deref`.
+#[experimental]
+pub struct DerefString<'a> {
+    x: DerefVec<'a, u8>
+}
+
+impl<'a> Deref<String> for DerefString<'a> {
+    fn deref<'b>(&'b self) -> &'b String {
+        unsafe { mem::transmute(&*self.x) }
+    }
+}
+
+/// Convert a string slice to a wrapper type providing a `&String` reference.
+#[experimental]
+pub fn as_string<'a>(x: &'a str) -> DerefString<'a> {
+    DerefString { x: as_vec(x.as_bytes()) }
+}
+
 /// Unsafe operations
 #[unstable = "waiting on raw module conventions"]
 pub mod raw {
@@ -1039,9 +1057,15 @@ mod tests {
     use {Mutable, MutableSeq};
     use str;
     use str::{Str, StrSlice, Owned};
-    use super::String;
+    use super::{as_string, String};
     use vec::Vec;
 
+    #[test]
+    fn test_as_string() {
+        let x = "foo";
+        assert_eq!(x, as_string(x).as_slice());
+    }
+
     #[test]
     fn test_from_str() {
       let owned: Option<::std::string::String> = from_str("string");

trunk/src/libcollections/vec.rs

@@ -18,7 +18,7 @@ use alloc::heap::{EMPTY, allocate, reallocate, deallocate};
 use core::cmp::max;
 use core::default::Default;
 use core::fmt;
-use core::kinds::marker::InvariantType;
+use core::kinds::marker::{ContravariantLifetime, InvariantType};
 use core::mem;
 use core::num;
 use core::ops;
@@ -1875,6 +1875,39 @@ pub fn unzip<T, U, V: Iterator<(T, U)>>(mut iter: V) -> (Vec<T>, Vec<U>) {
     (ts, us)
 }
 
+/// Wrapper type providing a `&Vec<T>` reference via `Deref`.
+#[experimental]
+pub struct DerefVec<'a, T> {
+    x: Vec<T>,
+    l: ContravariantLifetime<'a>
+}
+
+impl<'a, T> Deref<Vec<T>> for DerefVec<'a, T> {
+    fn deref<'b>(&'b self) -> &'b Vec<T> {
+        &self.x
+    }
+}
+
+// Prevent the inner `Vec<T>` from attempting to deallocate memory.
+#[unsafe_destructor]
+impl<'a, T> Drop for DerefVec<'a, T> {
+    fn drop(&mut self) {
+        self.x.len = 0;
+        self.x.cap = 0;
+    }
+}
+
+/// Convert a slice to a wrapper type providing a `&Vec<T>` reference.
+#[experimental]
+pub fn as_vec<'a, T>(x: &'a [T]) -> DerefVec<'a, T> {
+    unsafe {
+        DerefVec {
+            x: Vec::from_raw_parts(x.len(), x.len(), x.as_ptr() as *mut T),
+            l: ContravariantLifetime::<'a>
+        }
+    }
+}
+
 /// Unsafe vector operations.
 #[unstable]
 pub mod raw {
@@ -2169,10 +2202,38 @@ mod tests {
     use std::prelude::*;
     use std::mem::size_of;
     use test::Bencher;
-    use super::{unzip, raw, Vec};
+    use super::{as_vec, unzip, raw, Vec};
 
     use MutableSeq;
 
+    struct DropCounter<'a> {
+        count: &'a mut int
+    }
+
+    #[unsafe_destructor]
+    impl<'a> Drop for DropCounter<'a> {
+        fn drop(&mut self) {
+            *self.count += 1;
+        }
+    }
+
+    #[test]
+    fn test_as_vec() {
+        let xs = [1u8, 2u8, 3u8];
+        assert_eq!(as_vec(xs).as_slice(), xs.as_slice());
+    }
+
+    #[test]
+    fn test_as_vec_dtor() {
+        let (mut count_x, mut count_y) = (0, 0);
+        {
+            let xs = &[DropCounter { count: &mut count_x }, DropCounter { count: &mut count_y }];
+            assert_eq!(as_vec(xs).len(), 2);
+        }
+        assert_eq!(count_x, 1);
+        assert_eq!(count_y, 1);
+    }
+
     #[test]
     fn test_small_vec_struct() {
         assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
@@ -2185,17 +2246,6 @@ mod tests {
             y: Vec<T>
         }
 
-        struct DropCounter<'a> {
-            count: &'a mut int
-        }
-
-        #[unsafe_destructor]
-        impl<'a> Drop for DropCounter<'a> {
-            fn drop(&mut self) {
-                *self.count += 1;
-            }
-        }
-
         let (mut count_x, mut count_y) = (0, 0);
         {
             let mut tv = TwoVec {

trunk/src/libcore/slice.rs

@@ -1945,3 +1945,61 @@ impl<'a, T: PartialOrd> PartialOrd for &'a [T] {
         order::gt(self.iter(), other.iter())
     }
 }
+
+/// Extension methods for immutable slices containing integers.
+#[experimental]
+pub trait ImmutableIntSlice<'a, U, S> {
+    /// Converts the slice to an immutable slice of unsigned integers with the same width.
+    fn as_unsigned(self) -> &'a [U];
+    /// Converts the slice to an immutable slice of signed integers with the same width.
+    fn as_signed(self) -> &'a [S];
+}
+
+/// Extension methods for mutable slices containing integers.
+#[experimental]
+pub trait MutableIntSlice<'a, U, S>: ImmutableIntSlice<'a, U, S> {
+    /// Converts the slice to a mutable slice of unsigned integers with the same width.
+    fn as_unsigned_mut(self) -> &'a mut [U];
+    /// Converts the slice to a mutable slice of signed integers with the same width.
+    fn as_signed_mut(self) -> &'a mut [S];
+}
+
+macro_rules! impl_immut_int_slice {
+    ($u:ty, $s:ty, $t:ty) => {
+        #[experimental]
+        impl<'a> ImmutableIntSlice<'a, $u, $s> for $t {
+            #[inline]
+            fn as_unsigned(self) -> &'a [$u] { unsafe { transmute(self) } }
+            #[inline]
+            fn as_signed(self) -> &'a [$s] { unsafe { transmute(self) } }
+        }
+    }
+}
+macro_rules! impl_mut_int_slice {
+    ($u:ty, $s:ty, $t:ty) => {
+        #[experimental]
+        impl<'a> MutableIntSlice<'a, $u, $s> for $t {
+            #[inline]
+            fn as_unsigned_mut(self) -> &'a mut [$u] { unsafe { transmute(self) } }
+            #[inline]
+            fn as_signed_mut(self) -> &'a mut [$s] { unsafe { transmute(self) } }
+        }
+    }
+}
+
+macro_rules! impl_int_slice {
+    ($u:ty, $s:ty) => {
+        impl_immut_int_slice!($u, $s, &'a [$u])
+        impl_immut_int_slice!($u, $s, &'a [$s])
+        impl_immut_int_slice!($u, $s, &'a mut [$u])
+        impl_immut_int_slice!($u, $s, &'a mut [$s])
+        impl_mut_int_slice!($u, $s, &'a mut [$u])
+        impl_mut_int_slice!($u, $s, &'a mut [$s])
+    }
+}
+
+impl_int_slice!(u8,   i8)
+impl_int_slice!(u16,  i16)
+impl_int_slice!(u32,  i32)
+impl_int_slice!(u64,  i64)
+impl_int_slice!(uint, int)