---

yaml
---
r: 151494
b: refs/heads/try2
c: 426d022
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 58d540f0c6cdab817aba3705c9d4842b995ab4c9
+refs/heads/try2: 426d022732d02a86d53076e8a35e081f2e29c7cb
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/mk/crates.mk

@@ -52,7 +52,7 @@
 TARGET_CRATES := libc std green rustuv native flate arena glob term semver \
                  uuid serialize sync getopts collections num test time rand \
 		 workcache url log regex graphviz core
-HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros fmt_macros
+HOST_CRATES := syntax rustc rustdoc fourcc hexfloat regex_macros
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
@@ -61,7 +61,7 @@ DEPS_std := core libc native:rustrt native:compiler-rt native:backtrace
 DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
-DEPS_syntax := std term serialize collections log fmt_macros
+DEPS_syntax := std term serialize collections log
 DEPS_rustc := syntax native:rustllvm flate arena serialize sync getopts \
               collections time log
 DEPS_rustdoc := rustc native:hoedown serialize sync getopts collections \
@@ -88,7 +88,6 @@ DEPS_workcache := std serialize collections log
 DEPS_log := std sync
 DEPS_regex := std collections
 DEPS_regex_macros = syntax std regex
-DEPS_fmt_macros = std
 
 TOOL_DEPS_compiletest := test green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc native

branches/try2/src/compiletest/runtest.rs

@@ -997,7 +997,7 @@ fn make_lib_name(config: &config, auxfile: &Path, testfile: &Path) -> Path {
 fn make_exe_name(config: &config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
     if !os::consts::EXE_SUFFIX.is_empty() {
-        match f.filename().map(|s| Vec::from_slice(s).append(os::consts::EXE_SUFFIX.as_bytes())) {
+        match f.filename().map(|s| s + os::consts::EXE_SUFFIX.as_bytes()) {
             Some(v) => f.set_filename(v),
             None => ()
         }
@@ -1091,7 +1091,7 @@ fn make_out_name(config: &config, testfile: &Path, extension: &str) -> Path {
 
 fn aux_output_dir_name(config: &config, testfile: &Path) -> Path {
     let mut f = output_base_name(config, testfile);
-    match f.filename().map(|s| Vec::from_slice(s).append(bytes!(".libaux"))) {
+    match f.filename().map(|s| s + bytes!(".libaux")) {
         Some(v) => f.set_filename(v),
         None => ()
     }
@@ -1273,7 +1273,7 @@ fn append_suffix_to_stem(p: &Path, suffix: &str) -> Path {
         (*p).clone()
     } else {
         let stem = p.filestem().unwrap();
-        p.with_filename(Vec::from_slice(stem).append(bytes!("-")).append(suffix.as_bytes()))
+        p.with_filename(stem + bytes!("-") + suffix.as_bytes())
     }
 }
 

branches/try2/src/doc/guide-container.md

@@ -266,8 +266,8 @@ Iterators offer generic conversion to containers with the `collect` adaptor:
 
 ~~~
 let xs = [0, 1, 1, 2, 3, 5, 8];
-let ys = xs.iter().rev().skip(1).map(|&x| x * 2).collect::<Vec<int>>();
-assert_eq!(ys, vec![10, 6, 4, 2, 2, 0]);
+let ys = xs.iter().rev().skip(1).map(|&x| x * 2).collect::<~[int]>();
+assert_eq!(ys, ~[10, 6, 4, 2, 2, 0]);
 ~~~
 
 The method requires a type hint for the container type, if the surrounding code
@@ -278,14 +278,14 @@ implementing the `FromIterator` trait. For example, the implementation for
 vectors is as follows:
 
 ~~~ {.ignore}
-impl<T> FromIterator<T> for Vec<T> {
-    fn from_iter<I:Iterator<A>>(mut iterator: I) -> Vec<T> {
+impl<A> FromIterator<A> for ~[A] {
+    pub fn from_iter<T: Iterator<A>>(iterator: &mut T) -> ~[A] {
         let (lower, _) = iterator.size_hint();
-        let mut vector = Vec::with_capacity(lower);
-        for element in iterator {
-            vector.push(element);
+        let mut xs = with_capacity(lower);
+        for x in iterator {
+            xs.push(x);
         }
-        vector
+        xs
     }
 }
 ~~~

branches/try2/src/doc/rust.md

@@ -1741,10 +1741,10 @@ import public items from their destination, not private items.
 ## Attributes
 
 ~~~~ {.notrust .ebnf .gram}
-attribute : '#' '!' ? '[' meta_item ']' ;
-meta_item : ident [ '=' literal
-                  | '(' meta_seq ')' ] ? ;
-meta_seq : meta_item [ ',' meta_seq ]* ;
+attribute : '#' '!' ? '[' attr_list ']' ;
+attr_list : attr [ ',' attr_list ]* ;
+attr : ident [ '=' literal
+             | '(' attr_list ')' ] ? ;
 ~~~~
 
 Static entities in Rust — crates, modules and items — may have _attributes_
@@ -3598,18 +3598,18 @@ and the cast expression in `main`.
 Within the body of an item that has type parameter declarations, the names of its type parameters are types:
 
 ~~~~
-fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> Vec<B> {
+fn map<A: Clone, B: Clone>(f: |A| -> B, xs: &[A]) -> ~[B] {
     if xs.len() == 0 {
-       return vec![];
+       return ~[];
     }
     let first: B = f(xs[0].clone());
-    let rest: Vec<B> = map(f, xs.slice(1, xs.len()));
-    return vec![first].append(rest.as_slice());
+    let rest: ~[B] = map(f, xs.slice(1, xs.len()));
+    return ~[first] + rest;
 }
 ~~~~
 
 Here, `first` has type `B`, referring to `map`'s `B` type parameter;
-and `rest` has type `Vec<B>`, a vector type with element type `B`.
+and `rest` has type `~[B]`, a vector type with element type `B`.
 
 ### Self types
 

branches/try2/src/doc/tutorial.md

@@ -1588,8 +1588,8 @@ let mut numbers = vec![1, 2, 3];
 numbers.push(4);
 numbers.push(5);
 
-// The type of a unique vector is written as `Vec<int>`
-let more_numbers: Vec<int> = numbers.move_iter().map(|i| i+1).collect();
+// The type of a unique vector is written as `~[int]`
+let more_numbers: ~[int] = numbers.move_iter().collect();
 
 // The original `numbers` value can no longer be used, due to move semantics.
 
@@ -1633,7 +1633,7 @@ view[0] = 5;
 let ys: &mut [int] = &mut [1, 2, 3];
 ~~~
 
-Square brackets denote indexing into a slice or fixed-size vector:
+Square brackets denote indexing into a vector:
 
 ~~~~
 # enum Crayon { Almond, AntiqueBrass, Apricot,
@@ -1647,7 +1647,7 @@ match crayons[0] {
 }
 ~~~~
 
-A slice or fixed-size vector can be destructured using pattern matching:
+A vector can be destructured using pattern matching:
 
 ~~~~
 let numbers: &[int] = &[1, 2, 3];
@@ -1660,10 +1660,9 @@ let score = match numbers {
 ~~~~
 
 Both vectors and strings support a number of useful [methods](#methods),
-defined in [`std::vec`], [`std::slice`], and [`std::str`].
+defined in [`std::vec`] and [`std::str`].
 
 [`std::vec`]: std/vec/index.html
-[`std::slice`]: std/slice/index.html
 [`std::str`]: std/str/index.html
 
 # Ownership escape hatches

branches/try2/src/libcore/cast.rs

@@ -14,6 +14,32 @@ use mem;
 use intrinsics;
 use ptr::copy_nonoverlapping_memory;
 
+/// Casts the value at `src` to U. The two types must have the same length.
+#[inline]
+pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
+    let mut dest: U = mem::uninit();
+    let dest_ptr: *mut u8 = transmute(&mut dest);
+    let src_ptr: *u8 = transmute(src);
+    copy_nonoverlapping_memory(dest_ptr, src_ptr, mem::size_of::<U>());
+    dest
+}
+
+/**
+ * Move a thing into the void
+ *
+ * The forget function will take ownership of the provided value but neglect
+ * to run any required cleanup or memory-management operations on it.
+ */
+#[inline]
+pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing); }
+
+/**
+ * Force-increment the reference count on a shared box. If used
+ * carelessly, this can leak the box.
+ */
+#[inline]
+pub unsafe fn bump_box_refcount<T>(t: @T) { forget(t); }
+
 /**
  * Transform a value of one type into a value of another type.
  * Both types must have the same size and alignment.
@@ -28,29 +54,10 @@ use ptr::copy_nonoverlapping_memory;
  * ```
  */
 #[inline]
-pub unsafe fn transmute<T, U>(thing: T) -> U {
+pub unsafe fn transmute<L, G>(thing: L) -> G {
     intrinsics::transmute(thing)
 }
 
-/**
- * Move a thing into the void
- *
- * The forget function will take ownership of the provided value but neglect
- * to run any required cleanup or memory-management operations on it.
- */
-#[inline]
-pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing); }
-
-/// Casts the value at `src` to U. The two types must have the same length.
-#[inline]
-pub unsafe fn transmute_copy<T, U>(src: &T) -> U {
-    let mut dest: U = mem::uninit();
-    let dest_ptr: *mut u8 = transmute(&mut dest);
-    let src_ptr: *u8 = transmute(src);
-    copy_nonoverlapping_memory(dest_ptr, src_ptr, mem::size_of::<U>());
-    dest
-}
-
 /// Coerce an immutable reference to be mutable.
 #[inline]
 #[deprecated="casting &T to &mut T is undefined behaviour: use Cell<T>, RefCell<T> or Unsafe<T>"]
@@ -99,7 +106,7 @@ pub unsafe fn copy_lifetime_vec<'a,S,T>(_ptr: &'a [S], ptr: &T) -> &'a T {
 
 #[cfg(test)]
 mod tests {
-    use cast::transmute;
+    use cast::{bump_box_refcount, transmute};
     use raw;
     use realstd::str::StrAllocating;
 
@@ -108,6 +115,21 @@ mod tests {
         assert_eq!(1u, unsafe { ::cast::transmute_copy(&1) });
     }
 
+    #[test]
+    fn test_bump_managed_refcount() {
+        unsafe {
+            let managed = @"box box box".to_owned();      // refcount 1
+            bump_box_refcount(managed);     // refcount 2
+            let ptr: *int = transmute(managed); // refcount 2
+            let _box1: @~str = ::cast::transmute_copy(&ptr);
+            let _box2: @~str = ::cast::transmute_copy(&ptr);
+            assert!(*_box1 == "box box box".to_owned());
+            assert!(*_box2 == "box box box".to_owned());
+            // Will destroy _box1 and _box2. Without the bump, this would
+            // use-after-free. With too many bumps, it would leak.
+        }
+    }
+
     #[test]
     fn test_transmute() {
         unsafe {

branches/try2/src/libcore/cell.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Types that provide interior mutability.
+//! Types dealing with dynamic mutability
 
 use clone::Clone;
 use cmp::Eq;