---

yaml
---
r: 83850
b: refs/heads/try
c: b703061
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: 2e1df8e35bb0185dc35f5e7976c0b46608c32404
+refs/heads/try: b70306158ff41706e08c691596087502ba40f635
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/doc/rustpkg.md

@@ -137,9 +137,6 @@ and builds it in any workspace(s) where it finds one.
 Supposing such packages are found in workspaces X, Y, and Z,
 the command leaves behind files in `X`'s, `Y`'s, and `Z`'s `build` directories,
 but not in their `lib` or `bin` directories.
-(The exception is when rustpkg fetches a package `foo`'s sources from a remote repository.
-In that case, it stores both the sources *and* the build artifacts for `foo`
-in the workspace that `foo` will install to (see ##install below)).
 
 ## clean
 
@@ -151,11 +148,7 @@ in the workspace that `foo` will install to (see ##install below)).
 If `RUST_PATH` is declared as an environment variable, then rustpkg installs the
 libraries and executables into the `lib` and `bin` subdirectories
 of the first entry in `RUST_PATH`.
-Otherwise, if the current working directory CWD is a workspace,
-it installs them into CWD's `lib` and `bin` subdirectories.
-Otherwise, if the current working directory is CWD,
-it installs them into the .rust/lib and .rust/bin subdirectories of CWD
-(creating them if necessary). 
+Otherwise, it installs them into `foo`'s `lib` and `bin` directories.
 
 ## test
 

branches/try/doc/tutorial-ffi.md

@@ -135,7 +135,7 @@ the true length after compression for setting the length.
 ~~~~ {.xfail-test}
 pub fn compress(src: &[u8]) -> ~[u8] {
     #[fixed_stack_segment]; #[inline(never)];
-
+    
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = vec::raw::to_ptr(src);
@@ -157,7 +157,7 @@ format and `snappy_uncompressed_length` will retrieve the exact buffer size requ
 ~~~~ {.xfail-test}
 pub fn uncompress(src: &[u8]) -> Option<~[u8]> {
     #[fixed_stack_segment]; #[inline(never)];
-
+    
     unsafe {
         let srclen = src.len() as size_t;
         let psrc = vec::raw::to_ptr(src);
@@ -236,7 +236,7 @@ use std::libc::size_t;
 unsafe fn snappy_max_compressed_length(source_length: size_t) -> size_t {
     #[fixed_stack_segment]; #[inline(never)];
     return snappy_max_compressed_length(source_length);
-
+    
     #[link_args = "-lsnappy"]
     extern {
         fn snappy_max_compressed_length(source_length: size_t) -> size_t;
@@ -259,9 +259,9 @@ check that one of the following conditions holds:
 2. The call occurs inside of an `extern fn`;
 3. The call occurs within a stack closure created by some other
    safe fn.
-
+   
 All of these conditions ensure that you are running on a large stack
-segment. However, they are sometimes too strict. If your application
+segmented. However, they are sometimes too strict. If your application
 will be making many calls into C, it is often beneficial to promote
 the `#[fixed_stack_segment]` attribute higher up the call chain.  For
 example, the Rust compiler actually labels main itself as requiring a
@@ -298,7 +298,7 @@ impl<T: Send> Unique<T> {
     pub fn new(value: T) -> Unique<T> {
         #[fixed_stack_segment];
         #[inline(never)];
-
+        
         unsafe {
             let ptr = malloc(std::sys::size_of::<T>() as size_t) as *mut T;
             assert!(!ptr::is_null(ptr));
@@ -324,7 +324,7 @@ impl<T: Send> Drop for Unique<T> {
     fn drop(&mut self) {
         #[fixed_stack_segment];
         #[inline(never)];
-
+        
         unsafe {
             let x = intrinsics::init(); // dummy value to swap in
             // moving the object out is needed to call the destructor

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/librustc/driver/driver.rs

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

branches/try/src/librustc/front/config.rs

@@ -102,7 +102,6 @@ fn fold_foreign_mod(cx: &Context, nm: &ast::foreign_mod) -> ast::foreign_mod {
         }
     }.collect();
     ast::foreign_mod {
-        sort: nm.sort,
         abis: nm.abis,
         view_items: filtered_view_items,
         items: filtered_items

branches/try/src/librustc/metadata/creader.rs

@@ -175,40 +175,43 @@ fn visit_item(e: &Env, i: @ast::item) {
         }
 
         let cstore = e.cstore;
-        let mut already_added = false;
         let link_args = i.attrs.iter()
             .filter_map(|at| if "link_args" == at.name() {Some(at)} else {None})
             .collect::<~[&ast::Attribute]>();
 
-        match fm.sort {
-            ast::named => {
-                let link_name = i.attrs.iter()
-                    .find(|at| "link_name" == at.name())
-                    .and_then(|at| at.value_str());
-
-                let foreign_name = match link_name {
-                        Some(nn) => {
-                            if nn.is_empty() {
-                                e.diag.span_fatal(
-                                    i.span,
-                                    "empty #[link_name] not allowed; use \
-                                     #[nolink].");
-                            }
-                            nn
-                        }
-                        None => token::ident_to_str(&i.ident)
-                    };
-                if !attr::contains_name(i.attrs, "nolink") {
-                    already_added =
-                        !cstore::add_used_library(cstore, foreign_name);
-                }
-                if !link_args.is_empty() && already_added {
-                    e.diag.span_fatal(i.span, ~"library '" + foreign_name +
-                               "' already added: can't specify link_args.");
-                }
-            }
-            ast::anonymous => { /* do nothing */ }
-        }
+        // XXX: two whom it may concern, this was the old logic applied to the
+        //      ast's extern mod blocks which had names (we used to allow
+        //      "extern mod foo"). This code was never run for anonymous blocks,
+        //      and we now only have anonymous blocks. We're still in the midst
+        //      of figuring out what the exact operations we'd like to support
+        //      when linking external modules, but I wanted to leave this logic
+        //      here for the time beging to refer back to it
+
+        //let mut already_added = false;
+        //let link_name = i.attrs.iter()
+        //    .find(|at| "link_name" == at.name())
+        //    .and_then(|at| at.value_str());
+
+        //let foreign_name = match link_name {
+        //        Some(nn) => {
+        //            if nn.is_empty() {
+        //                e.diag.span_fatal(
+        //                    i.span,
+        //                    "empty #[link_name] not allowed; use \
+        //                     #[nolink].");
+        //            }
+        //            nn
+        //        }
+        //        None => token::ident_to_str(&i.ident)
+        //    };
+        //if !attr::contains_name(i.attrs, "nolink") {
+        //    already_added =
+        //        !cstore::add_used_library(cstore, foreign_name);
+        //}
+        //if !link_args.is_empty() && already_added {
+        //    e.diag.span_fatal(i.span, ~"library '" + foreign_name +
+        //               "' already added: can't specify link_args.");
+        //}
 
         for m in link_args.iter() {
             match m.value_str() {

branches/try/src/librustc/middle/privacy.rs

@@ -31,10 +31,6 @@ use syntax::visit::Visitor;
 
 type Context<'self> = (&'self method_map, &'self resolve::ExportMap2);
 
-// A set of all nodes in the ast which can be considered "publicly exported" in
-// the sense that they are accessible from anywhere in any hierarchy.
-pub type ExportedItems = HashSet<ast::NodeId>;
-
 // This visitor is used to determine the parent of all nodes in question when it
 // comes to privacy. This is used to determine later on if a usage is actually
 // valid or not.
@@ -141,7 +137,7 @@ impl<'self> Visitor<()> for ParentVisitor<'self> {
 // This visitor is used to determine which items of the ast are embargoed,
 // otherwise known as not exported.
 struct EmbargoVisitor<'self> {
-    exported_items: &'self mut ExportedItems,
+    exported_items: &'self mut HashSet<ast::NodeId>,
     exp_map2: &'self resolve::ExportMap2,
     path_all_public: bool,
 }
@@ -243,7 +239,7 @@ struct PrivacyVisitor<'self> {
     curitem: ast::NodeId,
 
     // Results of previous analyses necessary for privacy checking.
-    exported_items: &'self ExportedItems,
+    exported_items: &'self HashSet<ast::NodeId>,
     method_map: &'self method_map,
     parents: &'self HashMap<ast::NodeId, ast::NodeId>,
     external_exports: resolve::ExternalExports,
@@ -789,7 +785,7 @@ pub fn check_crate(tcx: ty::ctxt,
                    exp_map2: &resolve::ExportMap2,
                    external_exports: resolve::ExternalExports,
                    last_private_map: resolve::LastPrivateMap,
-                   crate: &ast::Crate) -> ExportedItems {
+                   crate: &ast::Crate) {
     let mut parents = HashMap::new();
     let mut exported_items = HashSet::new();
 
@@ -806,7 +802,7 @@ pub fn check_crate(tcx: ty::ctxt,
     {
         // Initialize the exported items with resolve's id for the "root crate"
         // to resolve references to `super` leading to the root and such.
-        exported_items.insert(ast::CRATE_NODE_ID);
+        exported_items.insert(0);
         let mut visitor = EmbargoVisitor {
             exported_items: &mut exported_items,
             exp_map2: exp_map2,
@@ -828,5 +824,4 @@ pub fn check_crate(tcx: ty::ctxt,
         };
         visit::walk_crate(&mut visitor, crate, ());
     }
-    return exported_items;
 }