---

yaml
---
r: 71759
b: refs/heads/dist-snap
c: a7f0bfb
h: refs/heads/master
i:
  71757: 263ba35
  71755: 8ece121
  71751: d56f6c8
  71743: 2b851b1
v: v3

Author: steveklabnik

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: b50030718cf28f2a5a81857a26b57442734fe854
-refs/heads/dist-snap: 84c296b27d3324b419e54bb5c899bd1fdc1f1008
+refs/heads/dist-snap: a7f0bfbda65d6ac2494d2270a96f45570dfb552e
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/doc/rust.md

@@ -441,10 +441,10 @@ expression context, the final namespace qualifier is omitted.
 Two examples of paths with type arguments:
 
 ~~~~
-# use core::hashmap::HashMap;
+# use core::hashmap::linear::LinearMap;
 # fn f() {
 # fn id<T:Copy>(t: T) -> T { t }
-type t = HashMap<int,~str>;  // Type arguments used in a type expression
+type t = LinearMap<int,~str>;  // Type arguments used in a type expression
 let x = id::<int>(10);         // Type arguments used in a call expression
 # }
 ~~~~
@@ -3251,6 +3251,28 @@ of runtime logging modules follows.
 * `::rt::backtrace` Log a backtrace on task failure
 * `::rt::callback` Unused
 
+#### Logging Expressions
+
+Rust provides several macros to log information. Here's a simple Rust program
+that demonstrates all four of them:
+
+```rust
+fn main() {
+    error!("This is an error log")
+    warn!("This is a warn log")
+    info!("this is an info log")
+    debug!("This is a debug log")
+}
+```
+
+These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
+
+```bash
+$ RUST_LOG=rust=3 ./rust
+rust: ~"\"This is an error log\""
+rust: ~"\"This is a warn log\""
+rust: ~"\"this is an info log\""
+```
 
 # Appendix: Rationales and design tradeoffs
 

branches/dist-snap/doc/tutorial.md

@@ -1888,8 +1888,8 @@ illegal to copy and pass by value.
 Generic `type`, `struct`, and `enum` declarations follow the same pattern:
 
 ~~~~
-# use core::hashmap::HashMap;
-type Set<T> = HashMap<T, ()>;
+# use core::hashmap::linear::LinearMap;
+type Set<T> = LinearMap<T, ()>;
 
 struct Stack<T> {
     elements: ~[T]

branches/dist-snap/src/libcore/at_vec.rs

@@ -208,7 +208,7 @@ pub mod raw {
      */
     #[inline(always)]
     pub unsafe fn set_len<T>(v: @[T], new_len: uint) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
+        let repr: **VecRepr = ::cast::reinterpret_cast(&addr_of(&v));
         (**repr).unboxed.fill = new_len * sys::size_of::<T>();
     }
 
@@ -226,7 +226,7 @@ pub mod raw {
 
     #[inline(always)] // really pretty please
     pub unsafe fn push_fast<T>(v: &mut @[T], initval: T) {
-        let repr: **mut VecRepr = ::cast::reinterpret_cast(&v);
+        let repr: **VecRepr = ::cast::reinterpret_cast(&v);
         let fill = (**repr).unboxed.fill;
         (**repr).unboxed.fill += sys::size_of::<T>();
         let p = addr_of(&((**repr).unboxed.data));

branches/dist-snap/src/libcore/cell.rs

@@ -10,7 +10,7 @@
 
 //! A mutable, nullable memory location
 
-use cast::transmute_mut;
+use cast::transmute;
 use prelude::*;
 
 /*
@@ -20,12 +20,16 @@ Similar to a mutable option type, but friendlier.
 */
 
 pub struct Cell<T> {
-    value: Option<T>
+    mut value: Option<T>
 }
 
 impl<T:cmp::Eq> cmp::Eq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
-        (self.value) == (other.value)
+        unsafe {
+            let frozen_self: &Option<T> = transmute(&mut self.value);
+            let frozen_other: &Option<T> = transmute(&mut other.value);
+            frozen_self == frozen_other
+        }
     }
     fn ne(&self, other: &Cell<T>) -> bool { !self.eq(other) }
 }
@@ -42,7 +46,6 @@ pub fn empty_cell<T>() -> Cell<T> {
 pub impl<T> Cell<T> {
     /// Yields the value, failing if the cell is empty.
     fn take(&self) -> T {
-        let mut self = unsafe { transmute_mut(self) };
         if self.is_empty() {
             fail!(~"attempt to take an empty cell");
         }
@@ -54,7 +57,6 @@ pub impl<T> Cell<T> {
 
     /// Returns the value, failing if the cell is full.
     fn put_back(&self, value: T) {
-        let mut self = unsafe { transmute_mut(self) };
         if !self.is_empty() {
             fail!(~"attempt to put a value back into a full cell");
         }

branches/dist-snap/src/libcore/gc.rs

@@ -43,7 +43,7 @@ use io;
 use libc::{size_t, uintptr_t};
 use option::{None, Option, Some};
 use ptr;
-use hashmap::HashSet;
+use hashmap::linear::LinearSet;
 use stackwalk;
 use sys;
 
@@ -344,7 +344,7 @@ pub fn cleanup_stack_for_failure() {
             ptr::null()
         };
 
-        let mut roots = HashSet::new();
+        let mut roots = LinearSet::new();
         for walk_gc_roots(need_cleanup, sentinel) |root, tydesc| {
             // Track roots to avoid double frees.
             if roots.contains(&*root) {