Fix rustdoc and tests.

5 files changed, 48 insertions, 68 deletions

diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs
index 3ad1ea8f0da..75ade160380 100644
--- a/src/libsyntax/ext/expand.rs
+++ b/src/libsyntax/ext/expand.rs
@@ -1044,7 +1044,7 @@ mod test {
         let crate_ast = parse::parse_crate_from_source_str(
             ~"<test>",
             src,
-            Vec::new(),sess);
+            Vec::new(), &sess);
         // should fail:
         let mut loader = ErrLoader;
         let cfg = ::syntax::ext::expand::ExpansionConfig {
@@ -1052,7 +1052,7 @@ mod test {
             deriving_hash_type_parameter: false,
             crate_id: from_str("test").unwrap(),
         };
-        expand_crate(sess,cfg,crate_ast);
+        expand_crate(&sess,cfg,crate_ast);
     }
 
     // make sure that macros can leave scope for modules
@@ -1064,7 +1064,7 @@ mod test {
         let crate_ast = parse::parse_crate_from_source_str(
             ~"<test>",
             src,
-            Vec::new(),sess);
+            Vec::new(), &sess);
         // should fail:
         let mut loader = ErrLoader;
         let cfg = ::syntax::ext::expand::ExpansionConfig {
@@ -1072,7 +1072,7 @@ mod test {
             deriving_hash_type_parameter: false,
             crate_id: from_str("test").unwrap(),
         };
-        expand_crate(sess,cfg,crate_ast);
+        expand_crate(&sess,cfg,crate_ast);
     }
 
     // macro_escape modules shouldn't cause macros to leave scope
@@ -1083,7 +1083,7 @@ mod test {
         let crate_ast = parse::parse_crate_from_source_str(
             ~"<test>",
             src,
-            Vec::new(), sess);
+            Vec::new(), &sess);
         // should fail:
         let mut loader = ErrLoader;
         let cfg = ::syntax::ext::expand::ExpansionConfig {
@@ -1091,7 +1091,7 @@ mod test {
             deriving_hash_type_parameter: false,
             crate_id: from_str("test").unwrap(),
         };
-        expand_crate(sess, cfg, crate_ast);
+        expand_crate(&sess, cfg, crate_ast);
     }
 
     #[test] fn test_contains_flatten (){
@@ -1127,7 +1127,7 @@ mod test {
 
     fn expand_crate_str(crate_str: ~str) -> ast::Crate {
         let ps = parse::new_parse_sess();
-        let crate_ast = string_to_parser(&ps, source_str).parse_crate_mod();
+        let crate_ast = string_to_parser(&ps, crate_str).parse_crate_mod();
         // the cfg argument actually does matter, here...
         let mut loader = ErrLoader;
         let cfg = ::syntax::ext::expand::ExpansionConfig {
diff --git a/src/libsyntax/fold.rs b/src/libsyntax/fold.rs
index 8cc74641db8..973682ea743 100644
--- a/src/libsyntax/fold.rs
+++ b/src/libsyntax/fold.rs
@@ -880,9 +880,9 @@ mod test {
     use super::*;
 
     // this version doesn't care about getting comments or docstrings in.
-    fn fake_print_crate(s: &mut pprust::State,
-                        krate: &ast::Crate) -> io::IoResult<()> {
-        pprust::print_mod(s, &krate.module, krate.attrs.as_slice())
+    fn fake_print_crate<A: pprust::PpAnn>(s: &mut pprust::State<A>,
+                                          krate: &ast::Crate) -> io::IoResult<()> {
+        s.print_mod(&krate.module, krate.attrs.as_slice())
     }
 
     // change every identifier to "zz"
@@ -914,9 +914,10 @@ mod test {
         let mut zz_fold = ToZzIdentFolder;
         let ast = string_to_crate(
             ~"#[a] mod b {fn c (d : e, f : g) {h!(i,j,k);l;m}}");
+        let folded_crate = zz_fold.fold_crate(ast);
         assert_pred!(matches_codepattern,
                      "matches_codepattern",
-                     pprust::to_str(&mut zz_fold.fold_crate(ast),fake_print_crate),
+                     pprust::to_str(|s| fake_print_crate(s, &folded_crate)),
                      ~"#[a]mod zz{fn zz(zz:zz,zz:zz){zz!(zz,zz,zz);zz;zz}}");
     }
 
@@ -926,9 +927,10 @@ mod test {
         let ast = string_to_crate(
             ~"macro_rules! a {(b $c:expr $(d $e:token)f+ => \
               (g $(d $d $e)+))} ");
+        let folded_crate = zz_fold.fold_crate(ast);
         assert_pred!(matches_codepattern,
                      "matches_codepattern",
-                     pprust::to_str(&mut zz_fold.fold_crate(ast),fake_print_crate),
+                     pprust::to_str(|s| fake_print_crate(s, &folded_crate)),
                      ~"zz!zz((zz$zz:zz$(zz $zz:zz)zz+=>(zz$(zz$zz$zz)+)))");
     }
 }
diff --git a/src/libsyntax/parse/lexer.rs b/src/libsyntax/parse/lexer.rs
index 43e1f8756fa..546aefc1297 100644
--- a/src/libsyntax/parse/lexer.rs
+++ b/src/libsyntax/parse/lexer.rs
@@ -1007,28 +1007,24 @@ mod test {
     use std::io::util;
     use std::vec_ng::Vec;
 
-    // represents a testing reader (incl. both reader and interner)
-    struct Env {
-        string_reader: StringReader
+    fn mk_sh() -> diagnostic::SpanHandler {
+        let emitter = diagnostic::EmitterWriter::new(~util::NullWriter);
+        let handler = diagnostic::mk_handler(~emitter);
+        diagnostic::mk_span_handler(handler, CodeMap::new())
     }
 
     // open a string reader for the given string
-    fn setup(teststr: ~str) -> Env {
-        let cm = CodeMap::new();
-        let fm = cm.new_filemap(~"zebra.rs", teststr);
-        let writer = ~util::NullWriter;
-        let emitter = diagnostic::EmitterWriter::new(writer);
-        let handler = diagnostic::mk_handler(~emitter);
-        let span_handler = diagnostic::mk_span_handler(handler, cm);
-        Env {
-            string_reader: new_string_reader(span_handler,fm)
-        }
+    fn setup<'a>(span_handler: &'a diagnostic::SpanHandler,
+                 teststr: ~str) -> StringReader<'a> {
+        let fm = span_handler.cm.new_filemap(~"zebra.rs", teststr);
+        new_string_reader(span_handler, fm)
     }
 
     #[test] fn t1 () {
-        let Env {string_reader} =
-            setup(~"/* my source file */ \
-                    fn main() { println!(\"zebra\"); }\n");
+        let span_handler = mk_sh();
+        let string_reader = setup(&span_handler,
+            ~"/* my source file */ \
+              fn main() { println!(\"zebra\"); }\n");
         let id = str_to_ident("fn");
         let tok1 = string_reader.next_token();
         let tok2 = TokenAndSpan{
@@ -1049,11 +1045,9 @@ mod test {
 
     // check that the given reader produces the desired stream
     // of tokens (stop checking after exhausting the expected vec)
-    fn check_tokenization (env: Env, expected: Vec<token::Token> ) {
+    fn check_tokenization (string_reader: StringReader, expected: Vec<token::Token> ) {
         for expected_tok in expected.iter() {
-            let TokenAndSpan {tok:actual_tok, sp: _} =
-                env.string_reader.next_token();
-            assert_eq!(&actual_tok,expected_tok);
+            assert_eq!(&string_reader.next_token().tok, expected_tok);
         }
     }
 
@@ -1063,71 +1057,55 @@ mod test {
     }
 
     #[test] fn doublecolonparsing () {
-        let env = setup (~"a b");
-        check_tokenization (env,
+        check_tokenization(setup(&mk_sh(), ~"a b"),
                            vec!(mk_ident("a",false),
                              mk_ident("b",false)));
     }
 
     #[test] fn dcparsing_2 () {
-        let env = setup (~"a::b");
-        check_tokenization (env,
+        check_tokenization(setup(&mk_sh(), ~"a::b"),
                            vec!(mk_ident("a",true),
                              token::MOD_SEP,
                              mk_ident("b",false)));
     }
 
     #[test] fn dcparsing_3 () {
-        let env = setup (~"a ::b");
-        check_tokenization (env,
+        check_tokenization(setup(&mk_sh(), ~"a ::b"),
                            vec!(mk_ident("a",false),
                              token::MOD_SEP,
                              mk_ident("b",false)));
     }
 
     #[test] fn dcparsing_4 () {
-        let env = setup (~"a:: b");
-        check_tokenization (env,
+        check_tokenization(setup(&mk_sh(), ~"a:: b"),
                            vec!(mk_ident("a",true),
                              token::MOD_SEP,
                              mk_ident("b",false)));
     }
 
     #[test] fn character_a() {
-        let env = setup(~"'a'");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        assert_eq!(tok,token::LIT_CHAR('a' as u32));
+        assert_eq!(setup(&mk_sh(), ~"'a'").next_token().tok,
+                   token::LIT_CHAR('a' as u32));
     }
 
     #[test] fn character_space() {
-        let env = setup(~"' '");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        assert_eq!(tok, token::LIT_CHAR(' ' as u32));
+        assert_eq!(setup(&mk_sh(), ~"' '").next_token().tok,
+                   token::LIT_CHAR(' ' as u32));
     }
 
     #[test] fn character_escaped() {
-        let env = setup(~"'\\n'");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        assert_eq!(tok, token::LIT_CHAR('\n' as u32));
+        assert_eq!(setup(&mk_sh(), ~"'\\n'").next_token().tok,
+                   token::LIT_CHAR('\n' as u32));
     }
 
     #[test] fn lifetime_name() {
-        let env = setup(~"'abc");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        let id = token::str_to_ident("abc");
-        assert_eq!(tok, token::LIFETIME(id));
+        assert_eq!(setup(&mk_sh(), ~"'abc").next_token().tok,
+                   token::LIFETIME(token::str_to_ident("abc")));
     }
 
     #[test] fn raw_string() {
-        let env = setup(~"r###\"\"#a\\b\x00c\"\"###");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        let id = token::str_to_ident("\"#a\\b\x00c\"");
-        assert_eq!(tok, token::LIT_STR_RAW(id, 3));
+        assert_eq!(setup(&mk_sh(), ~"r###\"\"#a\\b\x00c\"\"###").next_token().tok,
+                   token::LIT_STR_RAW(token::str_to_ident("\"#a\\b\x00c\""), 3));
     }
 
     #[test] fn line_doc_comments() {
@@ -1137,10 +1115,8 @@ mod test {
     }
 
     #[test] fn nested_block_comments() {
-        let env = setup(~"/* /* */ */'a'");
-        let TokenAndSpan {tok, sp: _} =
-            env.string_reader.next_token();
-        assert_eq!(tok,token::LIT_CHAR('a' as u32));
+        assert_eq!(setup(&mk_sh(), ~"/* /* */ */'a'").next_token().tok,
+                   token::LIT_CHAR('a' as u32));
     }
 
 }
diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs
index 79fedf82798..062bc100863 100644
--- a/src/libsyntax/parse/mod.rs
+++ b/src/libsyntax/parse/mod.rs
@@ -584,7 +584,8 @@ mod test {
     }
 
     #[test] fn parse_ident_pat () {
-        let mut parser = string_to_parser(&new_parse_sess(), ~"b");
+        let sess = new_parse_sess();
+        let mut parser = string_to_parser(&sess, ~"b");
         assert!(parser.parse_pat() ==
                    @ast::Pat{id: ast::DUMMY_NODE_ID,
                              node: ast::PatIdent(
diff --git a/src/libsyntax/util/parser_testing.rs b/src/libsyntax/util/parser_testing.rs
index 029486412ea..658e9709750 100644
--- a/src/libsyntax/util/parser_testing.rs
+++ b/src/libsyntax/util/parser_testing.rs
@@ -29,7 +29,8 @@ pub fn string_to_parser<'a>(ps: &'a ParseSess, source_str: ~str) -> Parser<'a> {
 }
 
 fn with_error_checking_parse<T>(s: ~str, f: |&mut Parser| -> T) -> T {
-    let mut p = string_to_parser(&new_parse_sess(), s);
+    let ps = new_parse_sess();
+    let mut p = string_to_parser(&ps, s);
     let x = f(&mut p);
     p.abort_if_errors();
     x