---

yaml
---
r: 114583
b: refs/heads/auto
c: 0e8e0b2
h: refs/heads/master
i:
  114581: 8abd550
  114579: 1d011e0
  114575: 6280c33
v: v3

Author: Armavica

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: f5bb16f76ea70c4fdefcbb307564be5c5c54c785
+refs/heads/auto: 0e8e0b2ede175be6a4874700674b259c8c63c2cc
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/LICENSE-MIT

@@ -1,4 +1,5 @@
-Copyright (c) 2014 The Rust Project Developers
+Copyright (c) 2006-2009 Graydon Hoare
+Copyright (c) 2009-2014 Mozilla Foundation
 
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated

branches/auto/src/doc/guide-pointers.md

@@ -186,7 +186,7 @@ enum List<T> {
     Nil,
     Cons(T, ~List<T>),
 }
-
+    
 fn main() {
     let list: List<int> = Cons(1, ~Cons(2, ~Cons(3, ~Nil)));
     println!("{:?}", list);
@@ -251,7 +251,7 @@ struct.
 
 > **Note**: the `@` form of managed pointers is deprecated and behind a
 > feature gate (it requires a `#![feature(managed_pointers)]` attribute on
-> the crate root). There are replacements, currently
+> the crate root; remember the semicolon!). There are replacements, currently 
 > there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
 > counting and garbage collection respectively.
 
@@ -266,7 +266,7 @@ struct Point {
     x: int,
     y: int,
 }
-
+    
 fn main() {
     let a = ~Point { x: 10, y: 20 };
     let b = a;
@@ -297,7 +297,7 @@ struct Point {
     x: int,
     y: int,
 }
-
+    
 fn main() {
     let a = @Point { x: 10, y: 20 };
     let b = a;
@@ -361,7 +361,7 @@ So how is this hard? Well, because we're ignoring ownership, the compiler needs
 to take great care to make sure that everything is safe. Despite their complete
 safety, a reference's representation at runtime is the same as that of
 an ordinary pointer in a C program. They introduce zero overhead. The compiler
-does all safety checks at compile time.
+does all safety checks at compile time. 
 
 This theory is called 'region pointers,' and involve a concept called
 'lifetimes'. Here's the simple explanation: would you expect this code to
@@ -477,7 +477,7 @@ fn main() {
 You may think that this gives us terrible performance: return a value and then
 immediately box it up?!?! Isn't that the worst of both worlds? Rust is smarter
 than that. There is no copy in this code. `main` allocates enough room for the
-`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes
+`@int`, passes a pointer to that memory into `foo` as `x`, and then `foo` writes 
 the value straight into that pointer. This writes the return value directly into
 the allocated box.
 

branches/auto/src/doc/guide-tasks.md

@@ -48,7 +48,13 @@ concurrency at this writing:
 * [`std::task`] - All code relating to tasks and task scheduling,
 * [`std::comm`] - The message passing interface,
 * [`sync::DuplexStream`] - An extension of `pipes::stream` that allows both sending and receiving,
+* [`sync::SyncSender`] - An extension of `pipes::stream` that provides synchronous message sending,
+* [`sync::SyncReceiver`] - An extension of `pipes::stream` that acknowledges each message received,
+* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the
+    message is received.
 * [`sync::Arc`] - The Arc (atomically reference counted) type, for safely sharing immutable data,
+* [`sync::RWArc`] - A dual-mode Arc protected by a reader-writer lock,
+* [`sync::MutexArc`] - An Arc with mutable data protected by a blocking mutex,
 * [`sync::Semaphore`] - A counting, blocking, bounded-waiting semaphore,
 * [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated
     FIFO condition variable,
@@ -64,8 +70,13 @@ concurrency at this writing:
 [`std::task`]: std/task/index.html
 [`std::comm`]: std/comm/index.html
 [`sync::DuplexStream`]: sync/struct.DuplexStream.html
+[`sync::SyncSender`]: sync/struct.SyncSender.html
+[`sync::SyncReceiver`]: sync/struct.SyncReceiver.html
+[`sync::rendezvous`]: sync/fn.rendezvous.html
 [`sync::Arc`]: sync/struct.Arc.html
-[`sync::Semaphore`]: sync/raw/struct.Semaphore.html
+[`sync::RWArc`]: sync/struct.RWArc.html
+[`sync::MutexArc`]: sync/struct.MutexArc.html
+[`sync::Semaphore`]: sync/struct.Semaphore.html
 [`sync::Mutex`]: sync/struct.Mutex.html
 [`sync::RWLock`]: sync/struct.RWLock.html
 [`sync::Barrier`]: sync/struct.Barrier.html
@@ -90,8 +101,6 @@ fn print_message() { println!("I am running in a different task!"); }
 spawn(print_message);
 
 // Print something more profound in a different task using a lambda expression
-// This uses the proc() keyword to assign to spawn a function with no name
-// That function will call println!(...) as requested
 spawn(proc() println!("I am also running in a different task!") );
 ~~~~
 

branches/auto/src/doc/tutorial.md

@@ -1720,103 +1720,38 @@ environment (sometimes referred to as "capturing" variables in their
 environment). For example, you couldn't write the following:
 
 ~~~~ {.ignore}
-let x = 3;
+let foo = 10;
 
-// `fun` cannot refer to `x`
-fn fun() -> () { println!("{}", x); }
+fn bar() -> int {
+   return foo; // `bar` cannot refer to `foo`
+}
 ~~~~
 
-A _closure_ does support accessing the enclosing scope; below we will create
-2 _closures_ (nameless functions). Compare how `||` replaces `()` and how
-they try to access `x`:
-
-~~~~ {.ignore}
-let x = 3;
-
-// `fun` is an invalid definition
-fn  fun       () -> () { println!("{}", x) }  // cannot capture from enclosing scope
-let closure = || -> () { println!("{}", x) }; // can capture from enclosing scope
+Rust also supports _closures_, functions that can access variables in
+the enclosing scope.
 
-// `fun_arg` is an invalid definition
-fn  fun_arg       (arg: int) -> () { println!("{}", arg + x) }  // cannot capture
-let closure_arg = |arg: int| -> () { println!("{}", arg + x) }; // can capture
-//                      ^
-// Requires a type because the implementation needs to know which `+` to use.
-// In the future, the implementation may not need the help.
+~~~~
+fn call_closure_with_ten(b: |int|) { b(10); }
 
-fun();          // Still won't work
-closure();      // Prints: 3
+let captured_var = 20;
+let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
 
-fun_arg(7);     // Still won't work
-closure_arg(7); // Prints: 10
+call_closure_with_ten(closure);
 ~~~~
 
 Closures begin with the argument list between vertical bars and are followed by
 a single expression. Remember that a block, `{ <expr1>; <expr2>; ... }`, is
 considered a single expression: it evaluates to the result of the last
 expression it contains if that expression is not followed by a semicolon,
-otherwise the block evaluates to `()`, the unit value.
-
-In general, return types and all argument types must be specified
-explicitly for function definitions.  (As previously mentioned in the
-[Functions section](#functions), omitting the return type from a
-function declaration is synonymous with an explicit declaration of
-return type unit, `()`.)
-
-~~~~ {.ignore}
-fn  fun   (x: int)         { println!("{}", x) } // this is same as saying `-> ()`
-fn  square(x: int) -> uint { (x * x) as uint }   // other return types are explicit
-
-// Error: mismatched types: expected `()` but found `uint`
-fn  badfun(x: int)         { (x * x) as uint }
-~~~~
-
-On the other hand, the compiler can usually infer both the argument
-and return types for a closure expression; therefore they are often
-omitted, since both a human reader and the compiler can deduce the
-types from the immediate context.  This is in contrast to function
-declarations, which require types to be specified and are not subject
-to type inference. Compare:
+otherwise the block evaluates to `()`.
 
-~~~~ {.ignore}
-// `fun` as a function declaration cannot infer the type of `x`, so it must be provided
-fn  fun       (x: int) { println!("{}", x) }
-let closure = |x     | { println!("{}", x) }; // infers `x: int`, return type `()`
-
-// For closures, omitting a return type is *not* synonymous with `-> ()`
-let add_3   = |y     | { 3i + y }; // infers `y: int`, return type `int`.
-
-fun(10);            // Prints 10
-closure(20);        // Prints 20
-closure(add_3(30)); // Prints 33
+The types of the arguments are generally omitted, as is the return type,
+because the compiler can almost always infer them. In the rare case where the
+compiler needs assistance, though, the arguments and return types may be
+annotated.
 
-fun("String"); // Error: mismatched types
-
-// Error: mismatched types
-// inference already assigned `closure` the type `|int| -> ()`
-closure("String");
 ~~~~
-
-In cases where the compiler needs assistance, the arguments and return
-types may be annotated on closures, using the same notation as shown
-earlier.  In the example below, since different types provide an
-implementation for the operator `*`, the argument type for the `x`
-parameter must be explicitly provided.
-
-~~~~{.ignore}
-// Error: the type of `x` must be known to be used with `x * x`
-let square = |x     | -> uint { (x * x) as uint };
-~~~~
-
-In the corrected version, the argument type is explicitly annotated,
-while the return type can still be inferred.
-
-~~~~
-let square_explicit = |x: int| -> uint { (x * x) as uint };
-let square_infer    = |x: int|         { (x * x) as uint };
-
-println!("{}", square_explicit(20));  // 400
-println!("{}", square_infer(-20));    // 400
+let square = |x: int| -> uint { (x * x) as uint };
 ~~~~
 
 There are several forms of closure, each with its own role. The most

branches/auto/src/etc/emacs/README.md

@@ -12,12 +12,11 @@ To install manually, check out this repository and add this to your
 
 ```lisp
 (add-to-list 'load-path "/path/to/rust-mode/")
-(autoload 'rust-mode "rust-mode" nil t)
-(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-mode))
+(require 'rust-mode)
 ```
 
-This associates `rust-mode` with `.rs` files. To enable it explicitly, do
-<kbd>M-x rust-mode</kbd>.
+`rust-mode` will automatically be associated with `.rs` files. To enable it
+explicitly, do <kbd>M-x rust-mode</kbd>.
 
 ### `package.el` installation via Marmalade or MELPA
 

branches/auto/src/libcollections/bitv.rs

@@ -225,32 +225,6 @@ enum BitvVariant { Big(BigBitv), Small(SmallBitv) }
 enum Op {Union, Intersect, Assign, Difference}
 
 /// The bitvector type
-///
-/// # Example
-///
-/// ```rust
-/// use collections::bitv::Bitv;
-///
-/// let mut bv = Bitv::new(10, false);
-///
-/// // insert all primes less than 10
-/// bv.set(2, true);
-/// bv.set(3, true);
-/// bv.set(5, true);
-/// bv.set(7, true);
-/// println!("{}", bv.to_str());
-/// println!("# bits set to true: {}", bv.iter().count(|x| x));
-///
-/// // flip all values in bitvector, producing non-primes less than 10
-/// bv.negate();
-/// println!("{}", bv.to_str());
-/// println!("# bits set to true: {}", bv.iter().count(|x| x));
-///
-/// // reset bitvector to empty
-/// bv.clear();
-/// println!("{}", bv.to_str());
-/// println!("# bits set to true: {}", bv.iter().count(|x| x));
-/// ```
 #[deriving(Clone)]
 pub struct Bitv {
     /// Internal representation of the bit vector (small or large)
@@ -290,11 +264,10 @@ impl Bitv {
           }
         }
     }
+
 }
 
 impl Bitv {
-    /// Creates an empty Bitv that holds `nbits` elements, setting each element
-    /// to `init`.
     pub fn new(nbits: uint, init: bool) -> Bitv {
         let rep = if nbits < uint::BITS {
             Small(SmallBitv::new(if init {(1<<nbits)-1} else {0}))
@@ -446,20 +419,6 @@ impl Bitv {
       }
     }
 
-    /// Returns an iterator over the elements of the vector in order.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// let mut bv = Bitv::new(10, false);
-    /// bv.set(1, true);
-    /// bv.set(2, true);
-    /// bv.set(3, true);
-    /// bv.set(5, true);
-    /// bv.set(8, true);
-    /// // Count bits set to 1; result should be 5
-    /// println!("{}", bv.iter().count(|x| x));
-    /// ```
     #[inline]
     pub fn iter<'a>(&'a self) -> Bits<'a> {
         Bits {bitv: self, next_idx: 0, end_idx: self.nbits}

branches/auto/src/libnative/io/file_win32.rs

@@ -274,7 +274,7 @@ pub fn open(path: &CString, fm: io::FileMode, fa: io::FileAccess)
         (io::Truncate, io::Read) => libc::TRUNCATE_EXISTING,
         (io::Truncate, _) => libc::CREATE_ALWAYS,
         (io::Open, io::Read) => libc::OPEN_EXISTING,
-        (io::Open, _) => libc::OPEN_ALWAYS,
+        (io::Open, _) => libc::CREATE_NEW,
         (io::Append, io::Read) => {
             dwDesiredAccess |= libc::FILE_APPEND_DATA;
             libc::OPEN_EXISTING

branches/auto/src/librustc/driver/driver.rs

@@ -210,6 +210,7 @@ pub fn phase_2_configure_and_expand(sess: &Session,
                                     -> (ast::Crate, syntax::ast_map::Map) {
     let time_passes = sess.time_passes();
 
+    sess.building_library.set(session::building_library(&sess.opts, &krate));
     *sess.crate_types.borrow_mut() = session::collect_crate_types(sess, krate.attrs.as_slice());
 
     time(time_passes, "gated feature checking", (), |_|
@@ -1045,6 +1046,7 @@ pub fn build_session_(sopts: session::Options,
         entry_type: Cell::new(None),
         macro_registrar_fn: Cell::new(None),
         default_sysroot: default_sysroot,
+        building_library: Cell::new(false),
         local_crate_source_file: local_crate_source_file,
         working_dir: os::getcwd(),
         lints: RefCell::new(NodeMap::new()),

branches/auto/src/librustc/driver/session.rs

@@ -25,6 +25,7 @@ use syntax::codemap::Span;
 use syntax::diagnostic;
 use syntax::parse::ParseSess;
 use syntax::{abi, ast, codemap};
+use syntax;
 
 use std::cell::{Cell, RefCell};
 use collections::HashSet;
@@ -184,6 +185,7 @@ pub struct Session {
     pub entry_type: Cell<Option<EntryFnType>>,
     pub macro_registrar_fn: Cell<Option<ast::NodeId>>,
     pub default_sysroot: Option<Path>,
+    pub building_library: Cell<bool>,
     // The name of the root source file of the crate, in the local file system. The path is always
     // expected to be absolute. `None` means that there is no source file.
     pub local_crate_source_file: Option<Path>,
@@ -475,6 +477,26 @@ pub fn expect<T:Clone>(sess: &Session, opt: Option<T>, msg: || -> ~str) -> T {
     diagnostic::expect(sess.diagnostic(), opt, msg)
 }
 
+pub fn building_library(options: &Options, krate: &ast::Crate) -> bool {
+    if options.test { return false }
+    for output in options.crate_types.iter() {
+        match *output {
+            CrateTypeExecutable => {}
+            CrateTypeStaticlib | CrateTypeDylib | CrateTypeRlib => return true
+        }
+    }
+    match syntax::attr::first_attr_value_str_by_name(krate.attrs.as_slice(),
+                                                     "crate_type") {
+        Some(s) => {
+            s.equiv(&("lib")) ||
+            s.equiv(&("rlib")) ||
+            s.equiv(&("dylib")) ||
+            s.equiv(&("staticlib"))
+        }
+        _ => false
+    }
+}
+
 pub fn default_lib_output() -> CrateType {
     CrateTypeRlib
 }