---

yaml
---
r: 83838
b: refs/heads/try
c: caf7b67
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0e4d1fc8cae42e15e00f71d9f439b01bb25a86ae
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
-refs/heads/try: 0ede2ea4e2e9384ac5bd614012d85ed213873dab
+refs/heads/try: caf7b678dd2f07918b47120aa73a1bca51d12da1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/compiletest/errors.rs

@@ -8,29 +8,24 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::io;
+
 pub struct ExpectedError { line: uint, kind: ~str, msg: ~str }
 
 // Load any test directives embedded in the file
 pub fn load_errors(testfile: &Path) -> ~[ExpectedError] {
-    use std::rt::io::Open;
-    use std::rt::io::file::FileInfo;
-    use std::rt::io::buffered::BufferedReader;
-
     let mut error_patterns = ~[];
-    let mut rdr = BufferedReader::new(testfile.open_reader(Open).unwrap());
+    let rdr = io::file_reader(testfile).unwrap();
     let mut line_num = 1u;
-    loop {
-        let ln = match rdr.read_line() {
-            Some(ln) => ln, None => break,
-        };
+    while !rdr.eof() {
+        let ln = rdr.read_line();
         error_patterns.push_all_move(parse_expected(line_num, ln));
         line_num += 1u;
     }
     return error_patterns;
 }
 
 fn parse_expected(line_num: uint, line: ~str) -> ~[ExpectedError] {
-    let line = line.trim();
     let error_tag = ~"//~";
     let mut idx;
     match line.find_str(error_tag) {

branches/try/src/compiletest/header.rs

@@ -12,6 +12,8 @@ use common::config;
 use common;
 use util;
 
+use std::io;
+
 pub struct TestProps {
     // Lines that should be expected, in order, on standard out
     error_patterns: ~[~str],
@@ -102,23 +104,17 @@ pub fn is_test_ignored(config: &config, testfile: &Path) -> bool {
     !val
 }
 
-fn iter_header(testfile: &Path, it: &fn(&str) -> bool) -> bool {
-    use std::rt::io::Open;
-    use std::rt::io::file::FileInfo;
-    use std::rt::io::buffered::BufferedReader;
-
-    let mut rdr = BufferedReader::new(testfile.open_reader(Open).unwrap());
-    loop {
-        let ln = match rdr.read_line() {
-            Some(ln) => ln, None => break
-        };
+fn iter_header(testfile: &Path, it: &fn(~str) -> bool) -> bool {
+    let rdr = io::file_reader(testfile).unwrap();
+    while !rdr.eof() {
+        let ln = rdr.read_line();
 
         // Assume that any directives will be found before the first
         // module or function. This doesn't seem to be an optimization
         // with a warm page cache. Maybe with a cold one.
         if ln.starts_with("fn") || ln.starts_with("mod") {
             return true;
-        } else { if !(it(ln.trim())) { return false; } }
+        } else { if !(it(ln)) { return false; } }
     }
     return true;
 }

branches/try/src/compiletest/procsrv.rs

@@ -57,7 +57,7 @@ pub fn run(lib_path: &str,
     });
 
     for input in input.iter() {
-        proc.input().write(input.as_bytes());
+        proc.input().write_str(*input);
     }
     let output = proc.finish_with_output();
 

branches/try/src/libextra/base64.rs

@@ -64,11 +64,11 @@ impl<'self> ToBase64 for &'self [u8] {
      *
      * ```rust
      * extern mod extra;
-     * use extra::base64::{ToBase64, STANDARD};
+     * use extra::base64::{ToBase64, standard};
      *
      * fn main () {
-     *     let str = [52,32].to_base64(STANDARD);
-     *     println!("base 64 output: {}", str);
+     *     let str = [52,32].to_base64(standard);
+     *     println!("{}", str);
      * }
      * ```
      */
@@ -172,19 +172,16 @@ impl<'self> FromBase64 for &'self str {
      *
      * ```rust
      * extern mod extra;
-     * use extra::base64::{ToBase64, FromBase64, STANDARD};
+     * use extra::base64::{ToBase64, FromBase64, standard};
      * use std::str;
      *
      * fn main () {
-     *     let hello_str = bytes!("Hello, World").to_base64(STANDARD);
-     *     println!("base64 output: {}", hello_str);
-     *     let res = hello_str.from_base64();
-     *     if res.is_ok() {
-     *       let optBytes = str::from_utf8_opt(res.unwrap());
-     *       if optBytes.is_some() {
-     *         println!("decoded from base64: {}", optBytes.unwrap());
-     *       }
-     *     }
+     *     let hello_str = "Hello, World".to_base64(standard);
+     *     println!("{}", hello_str);
+     *     let bytes = hello_str.from_base64();
+     *     println!("{:?}", bytes);
+     *     let result_str = str::from_utf8(bytes);
+     *     println!("{}", result_str);
      * }
      * ```
      */

branches/try/src/librustc/driver/driver.rs

@@ -263,9 +263,10 @@ pub fn phase_3_run_analysis_passes(sess: Session,
                                           method_map, ty_cx));
 
     let maps = (external_exports, last_private_map);
-    time(time_passes, "privacy checking", maps, |(a, b)|
-         middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
-                                      a, b, crate));
+    let exported_items =
+        time(time_passes, "privacy checking", maps, |(a, b)|
+             middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
+                                          a, b, crate));
 
     time(time_passes, "effect checking", (), |_|
          middle::effect::check_crate(ty_cx, method_map, crate));
@@ -300,7 +301,8 @@ pub fn phase_3_run_analysis_passes(sess: Session,
 
     let reachable_map =
         time(time_passes, "reachability checking", (), |_|
-             reachable::find_reachable(ty_cx, method_map, crate));
+             reachable::find_reachable(ty_cx, method_map, exp_map2,
+                                       &exported_items));
 
     time(time_passes, "lint checking", (), |_|
          lint::check_crate(ty_cx, crate));