---

yaml
---
r: 52477
b: refs/heads/dist-snap
c: d9c8428
h: refs/heads/master
i:
  52475: a1f7565
v: v3

Author: pcwalton

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
 refs/heads/incoming: 44d4d6de762f3f9aae1fedcf454c66b79b3ad58d
-refs/heads/dist-snap: 7f0fa143bc06002d06064795cb92f8e9a4fec007
+refs/heads/dist-snap: d9c842847d8d0d99dab6431d5e0fd05843599e7b
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/AUTHORS.txt

@@ -26,6 +26,7 @@ Benjamin Jackman <[email protected]>
 Benjamin Kircher <[email protected]>
 Benjamin Peterson <[email protected]>
 Bilal Husain <[email protected]>
+Bill Fallon <[email protected]>
 Brendan Eich <[email protected]>
 Brian Anderson <[email protected]>
 Brian J. Burg <[email protected]>

branches/dist-snap/doc/rust.md

@@ -3018,6 +3018,11 @@ Local variables are immutable unless declared with `let mut`.  The
 declaration (so `let mut x, y` declares two mutable variables, `x` and
 `y`).
 
+Function parameters are immutable unless declared with `mut`. The
+`mut` keyword applies only to the following parameter (so `|mut x, y|`
+and `fn f(mut x: ~int, y: ~int)` declare one mutable variable `x` and
+one immutable variable `y`).
+
 Local variables are not initialized when allocated; the entire frame worth of
 local variables are allocated at once, on frame-entry, in an uninitialized
 state. Subsequent statements within a function may or may not initialize the

branches/dist-snap/doc/tutorial.md

@@ -1226,6 +1226,18 @@ match crayons[0] {
 }
 ~~~~
 
+A vector can be destructured using pattern matching:
+
+~~~~
+let numbers: [int * 3] = [1, 2, 3];
+let score = match numbers {
+    [] => 0,
+    [a] => a * 10,
+    [a, b] => a * 6 + b * 4,
+    [a, b, c, ..rest] => a * 5 + b * 3 + c * 2 + rest.len() as int
+};
+~~~~
+
 The elements of a vector _inherit the mutability of the vector_,
 and as such, individual elements may not be reassigned when the
 vector lives in an immutable slot.

branches/dist-snap/src/compiletest/errors.rs

@@ -33,34 +33,36 @@ fn load_errors(testfile: &Path) -> ~[expected_error] {
     return error_patterns;
 }
 
-fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] unsafe {
-    let error_tag = ~"//~";
-    let mut idx;
-    match str::find_str(line, error_tag) {
-      None => return ~[],
-      Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
-    }
+fn parse_expected(line_num: uint, line: ~str) -> ~[expected_error] {
+    unsafe {
+        let error_tag = ~"//~";
+        let mut idx;
+        match str::find_str(line, error_tag) {
+          None => return ~[],
+          Some(nn) => { idx = (nn as uint) + str::len(error_tag); }
+        }
 
-    // "//~^^^ kind msg" denotes a message expected
-    // three lines above current line:
-    let mut adjust_line = 0u;
-    let len = str::len(line);
-    while idx < len && line[idx] == ('^' as u8) {
-        adjust_line += 1u;
-        idx += 1u;
-    }
+        // "//~^^^ kind msg" denotes a message expected
+        // three lines above current line:
+        let mut adjust_line = 0u;
+        let len = str::len(line);
+        while idx < len && line[idx] == ('^' as u8) {
+            adjust_line += 1u;
+            idx += 1u;
+        }
 
-    // Extract kind:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let start_kind = idx;
-    while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
-    let kind = str::to_lower(str::slice(line, start_kind, idx));
+        // Extract kind:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let start_kind = idx;
+        while idx < len && line[idx] != (' ' as u8) { idx += 1u; }
+        let kind = str::to_lower(str::slice(line, start_kind, idx));
 
-    // Extract msg:
-    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
-    let msg = str::slice(line, idx, len);
+        // Extract msg:
+        while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
+        let msg = str::slice(line, idx, len);
 
-    debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
+        debug!("line=%u kind=%s msg=%s", line_num - adjust_line, kind, msg);
 
-    return ~[{line: line_num - adjust_line, kind: kind, msg: msg}];
+        return ~[{line: line_num - adjust_line, kind: kind, msg: msg}];
+    }
 }

branches/dist-snap/src/compiletest/header.rs

@@ -146,15 +146,17 @@ fn parse_name_directive(line: ~str, directive: ~str) -> bool {
 }
 
 fn parse_name_value_directive(line: ~str,
-                              directive: ~str) -> Option<~str> unsafe {
-    let keycolon = directive + ~":";
-    match str::find_str(line, keycolon) {
-        Some(colon) => {
-            let value = str::slice(line, colon + str::len(keycolon),
-                                   str::len(line));
-            debug!("%s: %s", directive,  value);
-            Some(value)
+                              directive: ~str) -> Option<~str> {
+    unsafe {
+        let keycolon = directive + ~":";
+        match str::find_str(line, keycolon) {
+            Some(colon) => {
+                let value = str::slice(line, colon + str::len(keycolon),
+                                       str::len(line));
+                debug!("%s: %s", directive,  value);
+                Some(value)
+            }
+            None => None
         }
-        None => None
     }
 }

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

@@ -273,7 +273,7 @@ fn check_expected_errors(expected_errors: ~[errors::expected_error],
                          procres: procres) {
 
     // true if we found the error in question
-    let found_flags = vec::to_mut(vec::from_elem(
+    let found_flags = vec::cast_to_mut(vec::from_elem(
         vec::len(expected_errors), false));
 
     if procres.status == 0 {

branches/dist-snap/src/libcargo/cargo.rc

@@ -52,7 +52,7 @@ use core::*;
 use core::dvec::DVec;
 use core::io::WriterUtil;
 use core::result::{Ok, Err};
-use core::hashmap::linear::LinearMap;
+use core::send_map::linear::LinearMap;
 use std::getopts::{optflag, optopt, opt_present};
 use std::map::HashMap;
 use std::{map, json, tempfile, term, sort, getopts};
@@ -465,19 +465,19 @@ fn parse_source(name: ~str, j: &json::Json) -> @Source {
 
     match *j {
         json::Object(j) => {
-            let mut url = match j.find_copy(&~"url") {
+            let mut url = match j.find(&~"url") {
                 Some(json::String(u)) => u,
                 _ => fail ~"needed 'url' field in source"
             };
-            let method = match j.find_copy(&~"method") {
+            let method = match j.find(&~"method") {
                 Some(json::String(u)) => u,
                 _ => assume_source_method(url)
             };
-            let key = match j.find_copy(&~"key") {
+            let key = match j.find(&~"key") {
                 Some(json::String(u)) => Some(u),
                 _ => None
             };
-            let keyfp = match j.find_copy(&~"keyfp") {
+            let keyfp = match j.find(&~"keyfp") {
                 Some(json::String(u)) => Some(u),
                 _ => None
             };
@@ -512,7 +512,7 @@ fn try_parse_sources(filename: &Path, sources: map::HashMap<~str, @Source>) {
 }
 
 fn load_one_source_package(src: @Source, p: &json::Object) {
-    let name = match p.find_copy(&~"name") {
+    let name = match p.find(&~"name") {
         Some(json::String(n)) => {
             if !valid_pkg_name(n) {
                 warn(~"malformed source json: "
@@ -529,7 +529,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let uuid = match p.find_copy(&~"uuid") {
+    let uuid = match p.find(&~"uuid") {
         Some(json::String(n)) => {
             if !is_uuid(n) {
                 warn(~"malformed source json: "
@@ -545,15 +545,15 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let url = match p.find_copy(&~"url") {
+    let url = match p.find(&~"url") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: " + src.name + ~" (missing url)");
             return;
         }
     };
 
-    let method = match p.find_copy(&~"method") {
+    let method = match p.find(&~"method") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: "
@@ -562,13 +562,13 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         }
     };
 
-    let reference = match p.find_copy(&~"ref") {
+    let reference = match p.find(&~"ref") {
         Some(json::String(n)) => Some(n),
         _ => None
     };
 
     let mut tags = ~[];
-    match p.find_copy(&~"tags") {
+    match p.find(&~"tags") {
         Some(json::List(js)) => {
           for js.each |j| {
                 match *j {
@@ -580,7 +580,7 @@ fn load_one_source_package(src: @Source, p: &json::Object) {
         _ => ()
     }
 
-    let description = match p.find_copy(&~"description") {
+    let description = match p.find(&~"description") {
         Some(json::String(n)) => n,
         _ => {
             warn(~"malformed source json: " + src.name
@@ -1135,28 +1135,30 @@ fn get_temp_workdir(c: &Cargo) -> Path {
     }
 }
 
-fn cmd_install(c: &Cargo) unsafe {
-    let wd = get_temp_workdir(c);
+fn cmd_install(c: &Cargo) {
+    unsafe {
+        let wd = get_temp_workdir(c);
 
-    if vec::len(c.opts.free) == 2u {
-        let cwd = os::getcwd();
-        let status = run::run_program(~"cp", ~[~"-R", cwd.to_str(),
-                                               wd.to_str()]);
+        if vec::len(c.opts.free) == 2u {
+            let cwd = os::getcwd();
+            let status = run::run_program(~"cp", ~[~"-R", cwd.to_str(),
+                                                   wd.to_str()]);
 
-        if status != 0 {
-            fail fmt!("could not copy directory: %s", cwd.to_str());
-        }
+            if status != 0 {
+                fail fmt!("could not copy directory: %s", cwd.to_str());
+            }
 
-        install_source(c, &wd);
-        return;
-    }
+            install_source(c, &wd);
+            return;
+        }
 
-    sync(c);
+        sync(c);
 
-    let query = c.opts.free[2];
-    c.current_install = query.to_str();
+        let query = c.opts.free[2];
+        c.current_install = query.to_str();
 
-    install_query(c, &wd, query);
+        install_query(c, &wd, query);
+    }
 }
 
 fn sync(c: &Cargo) {
@@ -1617,7 +1619,7 @@ fn dump_cache(c: &Cargo) {
     need_dir(&c.root);
 
     let out = c.root.push("cache.json");
-    let _root = json::Object(~LinearMap::new());
+    let _root = json::Object(~LinearMap());
 
     if os::path_exists(&out) {
         copy_warn(&out, &c.root.push("cache.json.old"));
@@ -1638,10 +1640,10 @@ fn dump_sources(c: &Cargo) {
 
     match io::buffered_file_writer(&out) {
         result::Ok(writer) => {
-            let mut hash = ~LinearMap::new();
+            let mut hash = ~LinearMap();
 
             for c.sources.each |k, v| {
-                let mut chash = ~LinearMap::new();
+                let mut chash = ~LinearMap();
 
                 chash.insert(~"url", json::String(v.url));
                 chash.insert(~"method", json::String(v.method));

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

@@ -154,7 +154,7 @@ pub pure fn from_elem<T: Copy>(n_elts: uint, t: T) -> @[T] {
  * Creates and initializes an immutable managed vector by moving all the
  * elements from an owned vector.
  */
-fn from_owned<T>(v: ~[T]) -> @[T] {
+pub fn from_owned<T>(v: ~[T]) -> @[T] {
     let mut av = @[];
     unsafe {
         raw::reserve(&mut av, v.len());
@@ -169,7 +169,7 @@ fn from_owned<T>(v: ~[T]) -> @[T] {
  * Creates and initializes an immutable managed vector by copying all the
  * elements of a slice.
  */
-fn from_slice<T:Copy>(v: &[T]) -> @[T] {
+pub fn from_slice<T:Copy>(v: &[T]) -> @[T] {
     from_fn(v.len(), |i| v[i])
 }
 

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

@@ -13,8 +13,6 @@
 #[forbid(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
-use option::Option;
-
 pub trait Container {
     /// Return the number of elements in the container
     pure fn len(&self) -> uint;
@@ -41,9 +39,6 @@ pub trait Map<K, V>: Mutable {
     /// Visit all values
     pure fn each_value(&self, f: fn(&V) -> bool);
 
-    /// Return the value corresponding to the key in the map
-    pure fn find(&self, key: &K) -> Option<&self/V>;
-
     /// Insert a key-value pair into the map. An existing value for a
     /// key is replaced by the new value. Return true if the key did
     /// not already exist in the map.

branches/dist-snap/src/libcore/core.rc

@@ -138,7 +138,7 @@ pub mod dvec_iter;
 pub mod dlist;
 #[path="iter-trait.rs"] #[merge = "iter-trait/dlist.rs"]
 pub mod dlist_iter;
-pub mod hashmap;
+pub mod send_map;
 
 
 /* Tasks and communication */

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

@@ -145,7 +145,7 @@ impl<A> DVec<A> {
     #[inline(always)]
     fn swap_mut(f: &fn(v: ~[mut A]) -> ~[mut A]) {
         do self.swap |v| {
-            vec::from_mut(f(vec::to_mut(move v)))
+            vec::cast_from_mut(f(vec::cast_to_mut(move v)))
         }
     }
 

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

@@ -56,7 +56,6 @@ delegate!(fn exp2(n: c_float) -> c_float = cmath::c_float_utils::exp2)
 delegate!(fn abs(n: c_float) -> c_float = cmath::c_float_utils::abs)
 delegate!(fn abs_sub(a: c_float, b: c_float) -> c_float =
     cmath::c_float_utils::abs_sub)
-delegate!(fn floor(n: c_float) -> c_float = cmath::c_float_utils::floor)
 delegate!(fn mul_add(a: c_float, b: c_float, c: c_float) -> c_float =
     cmath::c_float_utils::mul_add)
 delegate!(fn fmax(a: c_float, b: c_float) -> c_float =
@@ -141,6 +140,10 @@ pub pure fn ge(x: f32, y: f32) -> bool { return x >= y; }
 #[inline(always)]
 pub pure fn gt(x: f32, y: f32) -> bool { return x > y; }
 
+/// Returns `x` rounded down
+#[inline(always)]
+pub pure fn floor(x: f32) -> f32 { unsafe { floorf32(x) } }
+
 // FIXME (#1999): replace the predicates below with llvm intrinsics or
 // calls to the libmath macros in the rust runtime for performance.
 
@@ -298,6 +301,11 @@ impl f32: num::One {
     static pure fn one() -> f32 { 1.0 }
 }
 
+#[abi="rust-intrinsic"]
+pub extern {
+    fn floorf32(val: f32) -> f32;
+}
+
 //
 // Local Variables:
 // mode: rust