---

yaml
---
r: 149380
b: refs/heads/try2
c: 879e8aa
h: refs/heads/master
v: v3

Author: bors

[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: 34ffe3cc1c1c9855ecb47479761d812f64436c85
+refs/heads/try2: 879e8aa7be06a53cd6cd9cc714e85a13c909c0ea
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -19,13 +19,17 @@
 #
 # First, start with one of these build targets:
 #
-#   * all - The default. Builds a complete, bootstrapped compiler.
+#   * all - The default. Build a complete, bootstrapped compiler.
 #           `rustc` will be in `${target-triple}/stage2/bin/`. Run it
 #           directly from the build directory if you like. This also
 #           comes with docs in `doc/`.
 #
 #   * check - Run the complete test suite
 #
+#   * clean - Clean the build repertory. It is advised to run this
+#             command if you want to build Rust again, after an update
+#             of the git repository.
+#
 #   * install - Install Rust. Note that installation is not necessary
 #               to use the compiler.
 #
@@ -103,7 +107,7 @@
 #
 # </tips>
 #
-# <nittygritty>
+# <nitty-gritty>
 #
 # # The Rust Build System
 #
@@ -152,12 +156,12 @@
 # libraries are managed and versioned without polluting the common
 # areas of the filesystem.
 #
-# General rust binaries may stil live in the host bin directory; they
+# General rust binaries may still live in the host bin directory; they
 # will just link against the libraries in the target lib directory.
 #
 # Admittedly this is a little convoluted.
 #
-# </nittygritty>
+# </nitty-gritty>
 #
 
 ######################################################################

branches/try2/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/try2/src/doc/tutorial.md

@@ -1750,6 +1750,24 @@ closures, but they also own them: that is, no other code can access
 them. Owned closures are used in concurrent code, particularly
 for spawning [tasks][tasks].
 
+Closures can be used to spawn tasks.
+A practical example of this pattern is found when using the `spawn` function,
+which starts a new task.
+
+~~~~
+use std::task::spawn;
+
+// proc is the closure which will be spawned.
+spawn(proc() {
+    debug!("I'm a new task")
+});
+~~~~
+
+> ***Note:*** If you want to see the output of `debug!` statements, you will need to turn on
+> `debug!` logging.  To enable `debug!` logging, set the RUST_LOG environment
+> variable to the name of your crate, which, for a file named `foo.rs`, will be
+> `foo` (e.g., with bash, `export RUST_LOG=foo`).
+
 ## Closure compatibility
 
 Rust closures have a convenient subtyping property: you can pass any kind of
@@ -1771,45 +1789,6 @@ call_twice(function);
 > in small ways. At the moment they can be unsound in some
 > scenarios, particularly with non-copyable types.
 
-## Do syntax
-
-The `do` expression makes it easier to call functions that take procedures
-as arguments.
-
-Consider this function that takes a procedure:
-
-~~~~
-fn call_it(op: proc(v: int)) {
-    op(10)
-}
-~~~~
-
-As a caller, if we use a closure to provide the final operator
-argument, we can write it in a way that has a pleasant, block-like
-structure.
-
-~~~~
-# fn call_it(op: proc(v: int)) { }
-call_it(proc(n) {
-    println!("{}", n);
-});
-~~~~
-
-A practical example of this pattern is found when using the `spawn` function,
-which starts a new task.
-
-~~~~
-use std::task::spawn;
-spawn(proc() {
-    debug!("I'm a new task")
-});
-~~~~
-
-If you want to see the output of `debug!` statements, you will need to turn on
-`debug!` logging.  To enable `debug!` logging, set the RUST_LOG environment
-variable to the name of your crate, which, for a file named `foo.rs`, will be
-`foo` (e.g., with bash, `export RUST_LOG=foo`).
-
 # Methods
 
 Methods are like functions except that they always begin with a special argument,

branches/try2/src/libextra/test.rs

@@ -555,7 +555,7 @@ impl<T: Writer> ConsoleTestState<T> {
                 }
             }
         }
-        if_ok!(self.write_plain(format!("result of ratchet: {} matrics added, \
+        if_ok!(self.write_plain(format!("result of ratchet: {} metrics added, \
                                         {} removed, {} improved, {} regressed, \
                                         {} noise\n",
                                        added, removed, improved, regressed,

branches/try2/src/libextra/url.rs

@@ -55,6 +55,17 @@ pub struct Url {
     fragment: Option<~str>
 }
 
+#[deriving(Clone, Eq)]
+pub struct Path {
+    /// The path component of a URL, for example `/foo/bar`.
+    path: ~str,
+    /// The query component of a URL.  `~[(~"baz", ~"qux")]` represents the
+    /// fragment `baz=qux` in the above example.
+    query: Query,
+    /// The fragment component, such as `quz`.  Doesn't include the leading `#` character.
+    fragment: Option<~str>
+}
+
 /// An optional subcomponent of a URI authority component.
 #[deriving(Clone, Eq)]
 pub struct UserInfo {
@@ -88,6 +99,19 @@ impl Url {
     }
 }
 
+impl Path {
+    pub fn new(path: ~str,
+               query: Query,
+               fragment: Option<~str>)
+               -> Path {
+        Path {
+            path: path,
+            query: query,
+            fragment: fragment,
+        }
+    }
+}
+
 impl UserInfo {
     #[inline]
     pub fn new(user: ~str, pass: Option<~str>) -> UserInfo {
@@ -727,6 +751,21 @@ pub fn from_str(rawurl: &str) -> Result<Url, ~str> {
     Ok(Url::new(scheme, userinfo, host, port, path, query, fragment))
 }
 
+pub fn path_from_str(rawpath: &str) -> Result<Path, ~str> {
+    let (path, rest) = match get_path(rawpath, false) {
+        Ok(val) => val,
+        Err(e) => return Err(e)
+    };
+
+    // query and fragment
+    let (query, fragment) = match get_query_fragment(rest) {
+        Ok(val) => val,
+        Err(e) => return Err(e),
+    };
+
+    Ok(Path{ path: path, query: query, fragment: fragment })
+}
+
 impl FromStr for Url {
     fn from_str(s: &str) -> Option<Url> {
         match from_str(s) {
@@ -736,6 +775,15 @@ impl FromStr for Url {
     }
 }
 
+impl FromStr for Path {
+    fn from_str(s: &str) -> Option<Path> {
+        match path_from_str(s) {
+            Ok(path) => Some(path),
+            Err(_) => None
+        }
+    }
+}
+
 /**
  * Converts a URL from `Url` to string representation.
  *
@@ -780,18 +828,45 @@ pub fn to_str(url: &Url) -> ~str {
     format!("{}:{}{}{}{}", url.scheme, authority, url.path, query, fragment)
 }
 
+pub fn path_to_str(path: &Path) -> ~str {
+    let query = if path.query.is_empty() {
+        ~""
+    } else {
+        format!("?{}", query_to_str(&path.query))
+    };
+
+    let fragment = match path.fragment {
+        Some(ref fragment) => format!("\\#{}", encode_component(*fragment)),
+        None => ~"",
+    };
+
+    format!("{}{}{}", path.path, query, fragment)
+}
+
 impl ToStr for Url {
     fn to_str(&self) -> ~str {
         to_str(self)
     }
 }
 
+impl ToStr for Path {
+    fn to_str(&self) -> ~str {
+        path_to_str(self)
+    }
+}
+
 impl IterBytes for Url {
     fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
         self.to_str().iter_bytes(lsb0, f)
     }
 }
 
+impl IterBytes for Path {
+    fn iter_bytes(&self, lsb0: bool, f: to_bytes::Cb) -> bool {
+        self.to_str().iter_bytes(lsb0, f)
+    }
+}
+
 // Put a few tests outside of the 'test' module so they can test the internal
 // functions and those functions don't need 'pub'
 
@@ -899,6 +974,17 @@ mod tests {
         assert_eq!(&u.fragment, &Some(~"something"));
     }
 
+    #[test]
+    fn test_path_parse() {
+        let path = ~"/doc/~u?s=v#something";
+
+        let up = path_from_str(path);
+        let u = up.unwrap();
+        assert_eq!(&u.path, &~"/doc/~u");
+        assert_eq!(&u.query, &~[(~"s", ~"v")]);
+        assert_eq!(&u.fragment, &Some(~"something"));
+    }
+
     #[test]
     fn test_url_parse_host_slash() {
         let urlstr = ~"http://0.42.42.42/";
@@ -907,6 +993,13 @@ mod tests {
         assert!(url.path == ~"/");
     }
 
+    #[test]
+    fn test_path_parse_host_slash() {
+        let pathstr = ~"/";
+        let path = path_from_str(pathstr).unwrap();
+        assert!(path.path == ~"/");
+    }
+
     #[test]
     fn test_url_host_with_port() {
         let urlstr = ~"scheme://host:1234";
@@ -930,13 +1023,27 @@ mod tests {
         assert!(url.path == ~"/file_name.html");
     }
 
+    #[test]
+    fn test_path_with_underscores() {
+        let pathstr = ~"/file_name.html";
+        let path = path_from_str(pathstr).unwrap();
+        assert!(path.path == ~"/file_name.html");
+    }
+
     #[test]
     fn test_url_with_dashes() {
         let urlstr = ~"http://dotcom.com/file-name.html";
         let url = from_str(urlstr).unwrap();
         assert!(url.path == ~"/file-name.html");
     }
 
+    #[test]
+    fn test_path_with_dashes() {
+        let pathstr = ~"/file-name.html";
+        let path = path_from_str(pathstr).unwrap();
+        assert!(path.path == ~"/file-name.html");
+    }
+
     #[test]
     fn test_no_scheme() {
         assert!(get_scheme("noschemehere.html").is_err());
@@ -1017,6 +1124,14 @@ mod tests {
         assert!(u.query == ~[(~"ba%d ", ~"#&+")]);
     }
 
+    #[test]
+    fn test_path_component_encoding() {
+        let path = ~"/doc%20uments?ba%25d%20=%23%26%2B";
+        let p = path_from_str(path).unwrap();
+        assert!(p.path == ~"/doc uments");
+        assert!(p.query == ~[(~"ba%d ", ~"#&+")]);
+    }
+
     #[test]
     fn test_url_without_authority() {
         let url = ~"mailto:test@email.com";

branches/try2/src/librustc/back/archive.rs

@@ -173,6 +173,7 @@ impl Archive {
             if_ok!(fs::rename(file, &new_filename));
             inputs.push(new_filename);
         }
+        if inputs.len() == 0 { return Ok(()) }
 
         // Finally, add all the renamed files to this archive
         let mut args = ~[&self.dst];

branches/try2/src/librustc/middle/ty.rs

@@ -4142,7 +4142,7 @@ pub fn enum_variants(cx: ctxt, id: ast::DefId) -> @~[@VariantInfo] {
                                           .span_err(e.span,
                                                     format!("expected \
                                                              constant: {}",
-                                                            (*err)));
+                                                            *err));
                                     }
                                 },
                                 None => {}

branches/try2/src/librustc/middle/typeck/check/method.rs

@@ -1303,15 +1303,15 @@ impl<'a> LookupContext<'a> {
         self.tcx().sess.span_note(
             span,
             format!("candidate \\#{} is `{}`",
-                 (idx+1u),
+                 idx+1u,
                  ty::item_path_str(self.tcx(), did)));
     }
 
     fn report_param_candidate(&self, idx: uint, did: DefId) {
         self.tcx().sess.span_note(
             self.expr.span,
             format!("candidate \\#{} derives from the bound `{}`",
-                 (idx+1u),
+                 idx+1u,
                  ty::item_path_str(self.tcx(), did)));
     }
 
@@ -1320,7 +1320,7 @@ impl<'a> LookupContext<'a> {
             self.expr.span,
             format!("candidate \\#{} derives from the type of the receiver, \
                   which is the trait `{}`",
-                 (idx+1u),
+                 idx+1u,
                  ty::item_path_str(self.tcx(), did)));
     }
 

branches/try2/src/librustc/middle/typeck/check/mod.rs

@@ -3551,7 +3551,7 @@ pub fn check_enum_variants(ccx: @CrateCtxt,
                             ccx.tcx.sess.span_err(e.span, "expected signed integer constant");
                         }
                         Err(ref err) => {
-                            ccx.tcx.sess.span_err(e.span, format!("expected constant: {}", (*err)));
+                            ccx.tcx.sess.span_err(e.span, format!("expected constant: {}", *err));
                         }
                     }
                 },