---

yaml
---
r: 149381
b: refs/heads/try2
c: dcee327
h: refs/heads/master
i:
  149379: ba304d3
v: v3

Author: huonw

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

branches/try2/src/doc/tutorial.md

@@ -1750,24 +1750,6 @@ 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
@@ -1789,6 +1771,45 @@ 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: {} metrics added, \
+        if_ok!(self.write_plain(format!("result of ratchet: {} matrics added, \
                                         {} removed, {} improved, {} regressed, \
                                         {} noise\n",
                                        added, removed, improved, regressed,

branches/try2/src/libextra/url.rs

@@ -55,17 +55,6 @@ 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 {
@@ -99,19 +88,6 @@ 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 {
@@ -751,21 +727,6 @@ 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) {
@@ -775,15 +736,6 @@ 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.
  *
@@ -828,45 +780,18 @@ 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'
 
@@ -974,17 +899,6 @@ 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/";
@@ -993,13 +907,6 @@ 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";
@@ -1023,27 +930,13 @@ 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());
@@ -1124,14 +1017,6 @@ 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,7 +173,6 @@ 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/driver/driver.rs

@@ -27,9 +27,6 @@ use middle;
 use util::common::time;
 use util::ppaux;
 
-use extra::json;
-use serialize::Encodable;
-
 use std::cell::{Cell, RefCell};
 use std::hashmap::{HashMap,HashSet};
 use std::io;
@@ -157,7 +154,7 @@ pub enum Input {
 
 pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
     -> ast::Crate {
-    let krate = time(sess.time_passes(), "parsing", (), |_| {
+    time(sess.time_passes(), "parsing", (), |_| {
         match *input {
             FileInput(ref file) => {
                 parse::parse_crate_from_file(&(*file), cfg.clone(), sess.parse_sess)
@@ -169,15 +166,7 @@ pub fn phase_1_parse_input(sess: Session, cfg: ast::CrateConfig, input: &Input)
                                                    sess.parse_sess)
             }
         }
-    });
-
-    if sess.opts.debugging_opts & session::AST_JSON_NOEXPAND != 0 {
-        let mut stdout = io::stdout();
-        let mut json = json::PrettyEncoder::new(&mut stdout);
-        krate.encode(&mut json);
-    }
-
-    krate
+    })
 }
 
 // For continuing compilation after a parsed crate has been
@@ -231,16 +220,8 @@ pub fn phase_2_configure_and_expand(sess: Session,
     krate = time(time_passes, "prelude injection", krate, |krate|
                  front::std_inject::maybe_inject_prelude(sess, krate));
 
-    let (krate, map) = time(time_passes, "assinging node ids and indexing ast", krate, |krate|
-         front::assign_node_ids_and_map::assign_node_ids_and_map(sess, krate));
-
-    if sess.opts.debugging_opts & session::AST_JSON != 0 {
-        let mut stdout = io::stdout();
-        let mut json = json::PrettyEncoder::new(&mut stdout);
-        krate.encode(&mut json);
-    }
-
-    (krate, map)
+    time(time_passes, "assinging node ids and indexing ast", krate, |krate|
+         front::assign_node_ids_and_map::assign_node_ids_and_map(sess, krate))
 }
 
 pub struct CrateAnalysis {
@@ -447,15 +428,15 @@ pub fn stop_after_phase_1(sess: Session) -> bool {
         debug!("invoked with --parse-only, returning early from compile_input");
         return true;
     }
-    return sess.opts.debugging_opts & session::AST_JSON_NOEXPAND != 0;
+    return false;
 }
 
 pub fn stop_after_phase_2(sess: Session) -> bool {
     if sess.opts.no_analysis {
         debug!("invoked with --no-analysis, returning early from compile_input");
         return true;
     }
-    return sess.opts.debugging_opts & session::AST_JSON != 0;
+    return false;
 }
 
 pub fn stop_after_phase_5(sess: Session) -> bool {

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

@@ -65,9 +65,7 @@ debugging_opts!(
         GC,
         PRINT_LINK_ARGS,
         PRINT_LLVM_PASSES,
-        LTO,
-        AST_JSON,
-        AST_JSON_NOEXPAND
+        LTO
     ]
     0
 )
@@ -99,8 +97,6 @@ pub fn debugging_opts_map() -> ~[(&'static str, &'static str, u64)] {
       "Prints the llvm optimization passes being run",
       PRINT_LLVM_PASSES),
      ("lto", "Perform LLVM link-time optimizations", LTO),
-     ("ast-json", "Print the AST as JSON and halt", AST_JSON),
-     ("ast-json-noexpand", "Print the pre-expansion AST as JSON and halt", AST_JSON_NOEXPAND),
     ]
 }