---

yaml
---
r: 81327
b: refs/heads/snap-stage3
c: 1d6c011
h: refs/heads/master
i:
  81325: a1cb5ec
  81323: fdf7985
  81319: e549bd5
  81311: 43edf3e
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: bbbafc4e466e8026d30b9c47d1f104fd44815bef
+refs/heads/snap-stage3: 1d6c01148c7e0b96105e7553f4e935e31be906d5
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/etc/emacs/rust-mode-tests.el

@@ -196,6 +196,35 @@ This is some more text.  Fee fie fo fum.  Humpty dumpty sat on a wall.
  *very very very long string
  */"))
 
+(ert-deftest fill-paragraph-single-line-style-with-code-before ()
+  (test-fill-paragraph
+   "fn foo() { }
+/// This is my comment.  This is more of my comment.  This is even more."
+   "fn foo() { }
+/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more." 14))
+
+(ert-deftest fill-paragraph-single-line-style-with-code-after ()
+  (test-fill-paragraph
+   "/// This is my comment.  This is more of my comment.  This is even more.
+fn foo() { }"
+   "/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more.
+fn foo() { }" 1 73))
+
+(ert-deftest fill-paragraph-single-line-style-code-before-and-after ()
+  (test-fill-paragraph
+   "fn foo() { }
+/// This is my comment.  This is more of my comment.  This is even more.
+fn bar() { }"
+   "fn foo() { }
+/// This is my comment.  This is
+/// more of my comment.  This is
+/// even more.
+fn bar() { }" 14 67))
+
 (defun test-auto-fill (initial position inserted expected)
   (rust-test-manip-code 
    initial

branches/snap-stage3/src/etc/emacs/rust-mode.el

@@ -300,7 +300,8 @@
         (let
             ((fill-paragraph-function
               (if (not (eq fill-paragraph-function 'rust-fill-paragraph))
-                  fill-paragraph-function)))
+                  fill-paragraph-function))
+             (fill-paragraph-handle-comment t))
           (apply 'fill-paragraph args)
           t))))))
 

branches/snap-stage3/src/libstd/rt/io/process.rs

@@ -140,145 +140,5 @@ impl Drop for Process {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use prelude::*;
-    use super::*;
-
-    use rt::io::{Reader, Writer};
-    use rt::io::pipe::*;
-    use str;
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn smoke() {
-        let io = ~[];
-        let args = ProcessConfig {
-            program: "/bin/sh",
-            args: [~"-c", ~"true"],
-            env: None,
-            cwd: None,
-            io: io,
-        };
-        let p = Process::new(args);
-        assert!(p.is_some());
-        let mut p = p.unwrap();
-        assert_eq!(p.wait(), 0);
-    }
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn smoke_failure() {
-        let io = ~[];
-        let args = ProcessConfig {
-            program: "if-this-is-a-binary-then-the-world-has-ended",
-            args: [],
-            env: None,
-            cwd: None,
-            io: io,
-        };
-        let p = Process::new(args);
-        assert!(p.is_some());
-        let mut p = p.unwrap();
-        assert!(p.wait() != 0);
-    }
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn exit_reported_right() {
-        let io = ~[];
-        let args = ProcessConfig {
-            program: "/bin/sh",
-            args: [~"-c", ~"exit 1"],
-            env: None,
-            cwd: None,
-            io: io,
-        };
-        let p = Process::new(args);
-        assert!(p.is_some());
-        let mut p = p.unwrap();
-        assert_eq!(p.wait(), 1);
-    }
-
-    fn read_all(input: &mut Reader) -> ~str {
-        let mut ret = ~"";
-        let mut buf = [0, ..1024];
-        loop {
-            match input.read(buf) {
-                None | Some(0) => { break }
-                Some(n) => { ret = ret + str::from_utf8(buf.slice_to(n)); }
-            }
-        }
-        return ret;
-    }
-
-    fn run_output(args: ProcessConfig) -> ~str {
-        let p = Process::new(args);
-        assert!(p.is_some());
-        let mut p = p.unwrap();
-        assert!(p.io[0].is_none());
-        assert!(p.io[1].is_some());
-        let ret = read_all(p.io[1].get_mut_ref() as &mut Reader);
-        assert_eq!(p.wait(), 0);
-        return ret;
-    }
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn stdout_works() {
-        let pipe = PipeStream::new().unwrap();
-        let io = ~[Ignored, CreatePipe(pipe, false, true)];
-        let args = ProcessConfig {
-            program: "/bin/sh",
-            args: [~"-c", ~"echo foobar"],
-            env: None,
-            cwd: None,
-            io: io,
-        };
-        assert_eq!(run_output(args), ~"foobar\n");
-    }
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn set_cwd_works() {
-        let pipe = PipeStream::new().unwrap();
-        let io = ~[Ignored, CreatePipe(pipe, false, true)];
-        let cwd = Some("/");
-        let args = ProcessConfig {
-            program: "/bin/sh",
-            args: [~"-c", ~"pwd"],
-            env: None,
-            cwd: cwd,
-            io: io,
-        };
-        assert_eq!(run_output(args), ~"/\n");
-    }
-
-    #[test]
-    #[cfg(unix, not(android))]
-    #[ignore] // FIXME(#9341)
-    fn stdin_works() {
-        let input = PipeStream::new().unwrap();
-        let output = PipeStream::new().unwrap();
-        let io = ~[CreatePipe(input, true, false),
-                   CreatePipe(output, false, true)];
-        let args = ProcessConfig {
-            program: "/bin/sh",
-            args: [~"-c", ~"read line; echo $line"],
-            env: None,
-            cwd: None,
-            io: io,
-        };
-        let mut p = Process::new(args).expect("didn't create a proces?!");
-        p.io[0].get_mut_ref().write("foobar".as_bytes());
-        p.io[0] = None; // close stdin;
-        let out = read_all(p.io[1].get_mut_ref() as &mut Reader);
-        assert_eq!(p.wait(), 0);
-        assert_eq!(out, ~"foobar\n");
-    }
-}
+// Tests for this module can be found in the rtio-processes run-pass test, along
+// with the justification for why it's not located here.

branches/snap-stage3/src/libsyntax/ext/tt/macro_rules.rs

@@ -185,6 +185,79 @@ pub fn add_new_extension(cx: @ExtCtxt,
       _ => cx.span_bug(sp, "wrong-structured rhs")
     };
 
+    // Given `lhses` and `rhses`, this is the new macro we create
+    fn generic_extension(cx: @ExtCtxt,
+                         sp: Span,
+                         name: Ident,
+                         arg: &[ast::token_tree],
+                         lhses: &[@named_match],
+                         rhses: &[@named_match])
+                         -> MacResult {
+        if cx.trace_macros() {
+            println!("{}! \\{ {} \\}",
+                      cx.str_of(name),
+                      print::pprust::tt_to_str(
+                          &ast::tt_delim(@mut arg.to_owned()),
+                          get_ident_interner()));
+        }
+
+        // Which arm's failure should we report? (the one furthest along)
+        let mut best_fail_spot = dummy_sp();
+        let mut best_fail_msg = ~"internal error: ran no matchers";
+
+        let s_d = cx.parse_sess().span_diagnostic;
+
+        for (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
+            match *lhs {
+              @matched_nonterminal(nt_matchers(ref mtcs)) => {
+                // `none` is because we're not interpolating
+                let arg_rdr = new_tt_reader(
+                    s_d,
+                    None,
+                    arg.to_owned()
+                ) as @mut reader;
+                match parse(cx.parse_sess(), cx.cfg(), arg_rdr, *mtcs) {
+                  success(named_matches) => {
+                    let rhs = match rhses[i] {
+                        // okay, what's your transcriber?
+                        @matched_nonterminal(nt_tt(@ref tt)) => {
+                            match (*tt) {
+                                // cut off delimiters; don't parse 'em
+                                tt_delim(ref tts) => {
+                                    (*tts).slice(1u,(*tts).len()-1u).to_owned()
+                                }
+                                _ => cx.span_fatal(
+                                    sp, "macro rhs must be delimited")
+                            }
+                        },
+                        _ => cx.span_bug(sp, "bad thing in rhs")
+                    };
+                    // rhs has holes ( `$id` and `$(...)` that need filled)
+                    let trncbr = new_tt_reader(s_d, Some(named_matches),
+                                               rhs);
+                    let p = @Parser(cx.parse_sess(),
+                                    cx.cfg(),
+                                    trncbr as @mut reader);
+
+                    // Let the context choose how to interpret the result.
+                    // Weird, but useful for X-macros.
+                    return MRAny(@ParserAnyMacro {
+                        parser: p
+                    } as @AnyMacro);
+                  }
+                  failure(sp, ref msg) => if sp.lo >= best_fail_spot.lo {
+                    best_fail_spot = sp;
+                    best_fail_msg = (*msg).clone();
+                  },
+                  error(sp, ref msg) => cx.span_fatal(sp, (*msg))
+                }
+              }
+              _ => cx.bug("non-matcher found in parsed lhses")
+            }
+        }
+        cx.span_fatal(best_fail_spot, best_fail_msg);
+    }
+
     let exp = @MacroRulesSyntaxExpanderTTFun {
         name: name,
         lhses: lhses,