---

yaml
---
r: 103105
b: refs/heads/auto
c: ece12d8
h: refs/heads/master
i:
  103103: adca8e7
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: 74f3e0474b382160a6b0aec6e27fe239025519a0
+refs/heads/auto: ece12d8da675d8ae13954d2172347160eb7cb7f6
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/Makefile.in

@@ -103,7 +103,7 @@
 #
 # </tips>
 #
-# <nittygritty>
+# <nitty-gritty>
 #
 # # The Rust Build System
 #
@@ -157,7 +157,7 @@
 #
 # Admittedly this is a little convoluted.
 #
-# </nittygritty>
+# </nitty-gritty>
 #
 
 ######################################################################

branches/auto/mk/main.mk

@@ -446,13 +446,13 @@ all: $(ALL_TARGET_RULES) $(GENERATED) docs
 # $(1) is the name of the doc <section> in Makefile.in
 # pick everything between tags | remove first line | remove last line
 # | remove extra (?) line | strip leading `#` from lines
-SHOW_DOCS = $(Q)awk '/$(1)/,/<\/$(1)>/' $(S)/Makefile.in | sed '1d' | sed '$$d' | sed 's/^\# \?//'
+SHOW_DOCS = $(Q)awk '/<$(1)>/,/<\/$(1)>/' $(S)/Makefile.in | sed '1d' | sed '$$d' | sed 's/^\# \?//'
 
 help:
 	$(call SHOW_DOCS,help)
 
-hot-tips:
-	$(call SHOW_DOCS,hottips)
+tips:
+	$(call SHOW_DOCS,tips)
 
 nitty-gritty:
-	$(call SHOW_DOCS,nittygritty)
+	$(call SHOW_DOCS,nitty-gritty)

branches/auto/src/compiler-rt

@@ -1 +1 @@
-Subproject commit f4b221571ce6f05714c1f1c6fa48f1393499989c
+Subproject commit d4606f1818dd8dfeaa3e509cd1cbac4482c3513e

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

@@ -226,7 +226,8 @@ spawn(proc() {
 });
 ~~~
 
-Instead we can clone the `chan`, which allows for multiple senders.
+Instead we can use a `SharedChan`, a type that allows a single
+`Chan` to be shared by multiple senders.
 
 ~~~
 # use std::task::spawn;
@@ -245,13 +246,16 @@ let result = port.recv() + port.recv() + port.recv();
 # fn some_expensive_computation(_i: uint) -> int { 42 }
 ~~~
 
-Cloning a `Chan` produces a new handle to the same channel, allowing multiple
-tasks to send data to a single port. It also upgrades the channel internally in
-order to allow this functionality, which means that channels that are not
-cloned can avoid the overhead required to handle multiple senders. But this
-fact has no bearing on the channel's usage: the upgrade is transparent.
+Here we transfer ownership of the channel into a new `SharedChan` value.  Like
+`Chan`, `SharedChan` is a non-copyable, owned type (sometimes also referred to
+as an *affine* or *linear* type). Unlike with `Chan`, though, the programmer
+may duplicate a `SharedChan`, with the `clone()` method.  A cloned
+`SharedChan` produces a new handle to the same channel, allowing multiple
+tasks to send data to a single port.  Between `spawn`, `Chan` and
+`SharedChan`, we have enough tools to implement many useful concurrency
+patterns.
 
-Note that the above cloning example is somewhat contrived since
+Note that the above `SharedChan` example is somewhat contrived since
 you could also simply use three `Chan` pairs, but it serves to
 illustrate the point. For reference, written with multiple streams, it
 might look like the example below.

branches/auto/src/libextra/json.rs

@@ -59,7 +59,6 @@ the code for these traits: `#[deriving(Decodable, Encodable)]`
 To encode using Encodable :
 
 ```rust
-extern crate extra;
 extern crate serialize;
 use extra::json;
 use std::io;
@@ -99,7 +98,6 @@ A basic `ToJson` example using a TreeMap of attribute name / attribute value:
 
 
 ```rust
-extern crate extra;
 extern crate collections;
 
 use extra::json;
@@ -127,10 +125,9 @@ fn main() {
 }
 ```
 
-To decode a JSON string using `Decodable` trait :
+To decode a json string using `Decodable` trait :
 
 ```rust
-extern crate extra;
 extern crate serialize;
 use serialize::Decodable;
 
@@ -157,7 +154,6 @@ Create a struct called TestStruct1 and serialize and deserialize it to and from
 using the serialization API, using the derived serialization code.
 
 ```rust
-extern crate extra;
 extern crate serialize;
 use extra::json;
 use serialize::{Encodable, Decodable};
@@ -176,7 +172,7 @@ fn main() {
          {data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
     let encoded_str: ~str = json::Encoder::str_encode(&to_encode_object);
 
-    // To deserialize use the `extra::json::from_str` and `extra::json::Decoder`
+    // To unserialize use the `extra::json::from_str` and `extra::json::Decoder`
 
     let json_object = extra::json::from_str(encoded_str);
     let mut decoder = json::Decoder::new(json_object.unwrap());
@@ -186,11 +182,10 @@ fn main() {
 
 ## Using `ToJson`
 
-This example use the ToJson impl to deserialize the JSON string.
+This example use the ToJson impl to unserialize the json string.
 Example of `ToJson` trait implementation for TestStruct1.
 
 ```rust
-extern crate extra;
 extern crate serialize;
 extern crate collections;
 
@@ -217,13 +212,13 @@ impl ToJson for TestStruct1 {
 }
 
 fn main() {
-    // Serialization using our impl of to_json
+    // Seralization using our impl of to_json
 
     let test2: TestStruct1 = TestStruct1 {data_int: 1, data_str:~"toto", data_vector:~[2,3,4,5]};
     let tjson: json::Json = test2.to_json();
     let json_str: ~str = tjson.to_str();
 
-    // Deserialize like before.
+    // Unserialize like before.
 
     let mut decoder = json::Decoder::new(json::from_str(json_str).unwrap());
     // create the final object

branches/auto/src/libextra/test.rs

@@ -1110,7 +1110,7 @@ impl MetricMap {
 
 // Benchmarking
 
-/// A function that is opaque to the optimizer, to allow benchmarks to
+/// A function that is opaque to the optimiser, to allow benchmarks to
 /// pretend to use outputs to assist in avoiding dead-code
 /// elimination.
 ///

branches/auto/src/libgreen/sched.rs

@@ -86,7 +86,7 @@ pub struct Scheduler {
     /// A flag to tell the scheduler loop it needs to do some stealing
     /// in order to introduce randomness as part of a yield
     steal_for_yield: bool,
-    /// Bookkeeping for the number of tasks which are currently running around
+    /// Bookeeping for the number of tasks which are currently running around
     /// inside this pool of schedulers
     task_state: TaskState,
 

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

@@ -571,9 +571,7 @@ pub fn readdir(p: &CString) -> IoResult<~[Path]> {
                         else {
                             let fp_vec = vec::from_buf(
                                 fp_buf, wcslen(fp_buf) as uint);
-                            let fp_trimmed = str::truncate_utf16_at_nul(fp_vec);
-                            let fp_str = str::from_utf16(fp_trimmed)
-                                    .expect("rust_list_dir_wfd_fp_buf returned invalid UTF-16");
+                            let fp_str = str::from_utf16(fp_vec);
                             paths.push(Path::new(fp_str));
                         }
                         more_files = FindNextFileW(find_handle, wfd_ptr as HANDLE);

branches/auto/src/librustc/middle/privacy.rs

@@ -41,11 +41,6 @@ pub type ExportedItems = HashSet<ast::NodeId>;
 /// reexporting a public struct doesn't inline the doc).
 pub type PublicItems = HashSet<ast::NodeId>;
 
-/// Result of a checking operation - None => no errors were found. Some => an
-/// error and contains the span and message for reporting that error and
-/// optionally the same for a note about the error.
-type CheckResult = Option<(Span, ~str, Option<(Span, ~str)>)>;
-
 ////////////////////////////////////////////////////////////////////////////////
 /// The parent visitor, used to determine what's the parent of what (node-wise)
 ////////////////////////////////////////////////////////////////////////////////
@@ -515,50 +510,40 @@ impl<'a> PrivacyVisitor<'a> {
         }
     }
 
-    fn report_error(&self, result: CheckResult) -> bool {
-        match result {
-            None => true,
-            Some((span, msg, note)) => {
-                self.tcx.sess.span_err(span, msg);
-                match note {
-                    Some((span, msg)) => self.tcx.sess.span_note(span, msg),
-                    None => {},
-                }
-                false
-            },
-        }
-    }
-
-    /// Guarantee that a particular definition is public. Returns a CheckResult
-    /// which contains any errors found. These can be reported using `report_error`.
-    /// If the result is `None`, no errors were found.
+    /// Guarantee that a particular definition is public, possibly emitting an
+    /// error message if it's not.
     fn ensure_public(&self, span: Span, to_check: ast::DefId,
-                     source_did: Option<ast::DefId>, msg: &str) -> CheckResult {
+                     source_did: Option<ast::DefId>, msg: &str) -> bool {
         match self.def_privacy(to_check) {
-            ExternallyDenied => Some((span, format!("{} is private", msg), None)),
+            ExternallyDenied => {
+                self.tcx.sess.span_err(span, format!("{} is private", msg))
+            }
             DisallowedBy(id) => {
-                let (err_span, err_msg) = if id == source_did.unwrap_or(to_check).node {
-                    return Some((span, format!("{} is private", msg), None));
+                if id == source_did.unwrap_or(to_check).node {
+                    self.tcx.sess.span_err(span, format!("{} is private", msg));
+                    return false;
                 } else {
-                    (span, format!("{} is inaccessible", msg))
-                };
+                    self.tcx.sess.span_err(span, format!("{} is inaccessible",
+                                                         msg));
+                }
                 match self.tcx.map.find(id) {
                     Some(ast_map::NodeItem(item)) => {
                         let desc = match item.node {
                             ast::ItemMod(..) => "module",
                             ast::ItemTrait(..) => "trait",
-                            _ => return Some((err_span, err_msg, None)),
+                            _ => return false,
                         };
                         let msg = format!("{} `{}` is private",
                                           desc,
                                           token::get_ident(item.ident));
-                        Some((err_span, err_msg, Some((span, msg))))
-                    },
-                    _ => Some((err_span, err_msg, None)),
+                        self.tcx.sess.span_note(span, msg);
+                    }
+                    Some(..) | None => {}
                 }
-            },
-            Allowable => None,
+            }
+            Allowable => return true
         }
+        return false;
     }
 
     // Checks that a field is in scope.
@@ -628,99 +613,34 @@ impl<'a> PrivacyVisitor<'a> {
         let method_id = ty::method(self.tcx, method_id).provided_source
                                                        .unwrap_or(method_id);
 
-        let string = token::get_ident(name);
-        self.report_error(self.ensure_public(span,
-                                             method_id,
-                                             None,
-                                             format!("method `{}`", string)));
+        self.ensure_public(span,
+                           method_id,
+                           None,
+                           format!("method `{}`", token::get_ident(name)));
     }
 
     // Checks that a path is in scope.
     fn check_path(&mut self, span: Span, path_id: ast::NodeId, path: &ast::Path) {
         debug!("privacy - path {}", self.nodestr(path_id));
         let def_map = self.tcx.def_map.borrow();
-        let orig_def = def_map.get().get_copy(&path_id);
+        let def = def_map.get().get_copy(&path_id);
         let ck = |tyname: &str| {
-            let ck_public = |def: ast::DefId| {
-                let name = token::get_ident(path.segments
-                                                .last()
-                                                .unwrap()
-                                                .identifier);
-                let origdid = def_id_of_def(orig_def);
-                self.ensure_public(span,
-                                   def,
-                                   Some(origdid),
-                                   format!("{} `{}`",
-                                           tyname,
-                                           name))
-            };
-
+            let origdid = def_id_of_def(def);
             match *self.last_private_map.get(&path_id) {
-                resolve::LastMod(resolve::AllPublic) => {},
-                resolve::LastMod(resolve::DependsOn(def)) => {
-                    self.report_error(ck_public(def));
-                },
-                resolve::LastImport{value_priv: value_priv,
-                                    value_used: check_value,
-                                    type_priv: type_priv,
-                                    type_used: check_type} => {
-                    // This dance with found_error is because we don't want to report
-                    // a privacy error twice for the same directive.
-                    let found_error = match (type_priv, check_type) {
-                        (Some(resolve::DependsOn(def)), resolve::Used) => {
-                            !self.report_error(ck_public(def))
-                        },
-                        _ => false,
-                    };
-                    if !found_error {
-                        match (value_priv, check_value) {
-                            (Some(resolve::DependsOn(def)), resolve::Used) => {
-                                self.report_error(ck_public(def));
-                            },
-                            _ => {},
-                        }
-                    }
-                    // If an import is not used in either namespace, we still want to check
-                    // that it could be legal. Therefore we check in both namespaces and only
-                    // report an error if both would be illegal. We only report one error,
-                    // even if it is illegal to import from both namespaces.
-                    match (value_priv, check_value, type_priv, check_type) {
-                        (Some(p), resolve::Unused, None, _) |
-                        (None, _, Some(p), resolve::Unused) => {
-                            let p = match p {
-                                resolve::AllPublic => None,
-                                resolve::DependsOn(def) => ck_public(def),
-                            };
-                            if p.is_some() {
-                                self.report_error(p);
-                            }
-                        },
-                        (Some(v), resolve::Unused, Some(t), resolve::Unused) => {
-                            let v = match v {
-                                resolve::AllPublic => None,
-                                resolve::DependsOn(def) => ck_public(def),
-                            };
-                            let t = match t {
-                                resolve::AllPublic => None,
-                                resolve::DependsOn(def) => ck_public(def),
-                            };
-                            match (v, t) {
-                                (Some(_), Some(t)) => {
-                                    self.report_error(Some(t));
-                                },
-                                _ => {},
-                            }
-                        },
-                        _ => {},
-                    }
-                },
+                resolve::AllPublic => {},
+                resolve::DependsOn(def) => {
+                    let name = token::get_ident(path.segments
+                                                    .last()
+                                                    .unwrap()
+                                                    .identifier);
+                    self.ensure_public(span,
+                                       def,
+                                       Some(origdid),
+                                       format!("{} `{}`",
+                                               tyname, name));
+                }
             }
         };
-        // FIXME(#12334) Imports can refer to definitions in both the type and
-        // value namespaces. The privacy information is aware of this, but the
-        // def map is not. Therefore the names we work out below will not always
-        // be accurate and we can get slightly wonky error messages (but type
-        // checking is always correct).
         let def_map = self.tcx.def_map.borrow();
         match def_map.get().get_copy(&path_id) {
             ast::DefStaticMethod(..) => ck("static method"),
@@ -748,7 +668,7 @@ impl<'a> PrivacyVisitor<'a> {
             // is whether the trait itself is accessible or not.
             method_param(method_param { trait_id: trait_id, .. }) |
             method_object(method_object { trait_id: trait_id, .. }) => {
-                self.report_error(self.ensure_public(span, trait_id, None, "source trait"));
+                self.ensure_public(span, trait_id, None, "source trait");
             }
         }
     }