rustc: Implement a new resolve pass behind a compile flag

Author: pcwalton

src/libcore/comm.rs

@@ -27,8 +27,8 @@ io::println(comm::recv(p));
 import either::either;
 import libc::size_t;
 
-export port::{};
-export chan::{};
+export port;
+export chan;
 export send;
 export recv;
 export peek;

src/libcore/dvec.rs

@@ -200,6 +200,7 @@ impl extensions<A:copy> for dvec<A> {
         }
     }
 
+    /*
     #[doc = "
         Append all elements of an iterable.
 
@@ -222,6 +223,7 @@ impl extensions<A:copy> for dvec<A> {
            v
         }
     }
+    */
 
     #[doc = "
         Gets a copy of the current contents.
@@ -267,7 +269,28 @@ impl extensions<A:copy> for dvec<A> {
     }
 
     #[doc = "Returns the last element, failing if the vector is empty"]
+    #[inline(always)]
     fn last() -> A {
-        self.get_elt(self.len() - 1u)
+        self.check_not_borrowed();
+
+        let length = self.len();
+        if length == 0u {
+            fail "attempt to retrieve the last element of an empty vector";
+        }
+
+        ret self.data[length - 1u];
+    }
+
+    #[doc="Iterates over the elements in reverse order"]
+    #[inline(always)]
+    fn reach(f: fn(A) -> bool) {
+        let length = self.len();
+        let mut i = 0u;
+        while i < length {
+            if !f(self.get_elt(i)) {
+                break;
+            }
+            i += 1u;
+        }
     }
 }

src/libcore/future.rs

@@ -14,7 +14,6 @@ io::println(#fmt(\"fib(5000) = %?\", delayed_fib.get()))
 import either::either;
 
 export future;
-export future::{};
 export from_value;
 export from_port;
 export from_fn;

src/libcore/newcomm.rs

@@ -6,6 +6,7 @@ avoid needing a single global lock."]
 import arc::methods;
 import dvec::dvec;
 import dvec::{extensions};
+import sys::methods;
 
 export port;
 export chan;

src/libcore/task.rs

@@ -24,14 +24,15 @@ spawn {||
 
 import result::result;
 import dvec::extensions;
+import dvec_iter::extensions;
 
 export task;
 export task_result;
 export notification;
 export sched_mode;
 export sched_opts;
 export task_opts;
-export builder::{};
+export builder;
 
 export default_task_opts;
 export get_opts;

src/libstd/json.rs

@@ -8,6 +8,7 @@ import io;
 import io::{reader_util, writer_util};
 import map;
 import map::hashmap;
+import core::vec::extensions;
 
 export json;
 export error;

src/libstd/list.rs

@@ -102,6 +102,11 @@ pure fn append<T: copy>(l: @list<T>, m: @list<T>) -> @list<T> {
     }
 }
 
+#[doc = "Push an element to the front of a list"]
+fn push<T: copy>(&l: list<T>, v: T) {
+    l = cons(v, @l);
+}
+
 #[doc = "Iterate over a list"]
 fn iter<T>(l: @list<T>, f: fn(T)) {
     let mut cur = l;

src/libstd/par.rs

@@ -4,6 +4,7 @@ import comm::send;
 import comm::recv;
 import future_spawn = future::spawn;
 import future::future;
+import core::vec::extensions;
 
 export map, mapi, alli, any, mapi_factory;
 

src/libstd/tempfile.rs

@@ -3,6 +3,7 @@
 import core::option;
 import option::{none, some};
 import rand;
+import core::rand::extensions;
 
 fn mkdtemp(prefix: str, suffix: str) -> option<str> {
     let r = rand::rng();

src/libstd/uv_iotask.rs

@@ -7,7 +7,7 @@ The I/O task runs in its own single-threaded scheduler.  By using the
 
 "];
 
-export iotask::{};
+export iotask;
 export spawn_iotask;
 export interact;
 export exit;

src/libsyntax/ast_util.rs

@@ -572,6 +572,13 @@ fn walk_pat(pat: @pat, it: fn(@pat)) {
     }
 }
 
+fn view_path_id(p: @view_path) -> node_id {
+    alt p.node {
+      view_path_simple(_, _, id) | view_path_glob(_, id) |
+      view_path_list(_, _, id) { id }
+    }
+}
+
 // Local Variables:
 // mode: rust
 // fill-column: 78;

src/libsyntax/codemap.rs

@@ -4,6 +4,9 @@ export filename;
 export filemap;
 export span;
 export file_substr;
+export fss_none;
+export fss_internal;
+export fss_external;
 export codemap;
 export expn_info;
 export expn_info_;

src/libsyntax/parse.rs

@@ -18,8 +18,8 @@ import common::parser_common;
 import ast::node_id;
 import util::interner;
 // FIXME (#1935): resolve badness
-import lexer::*;//{string_reader_as_reader, tt_reader_as_reader,
-               //reader, string_reader, tt_reader};
+import lexer::{string_reader_as_reader, tt_reader_as_reader, reader,
+               string_reader, tt_reader};
 import diagnostic::{span_handler, mk_span_handler, mk_handler, emitter};
 
 type parse_sess = @{

src/libsyntax/parse/classify.rs

@@ -1,7 +1,8 @@
 /*
   Predicates on exprs and stmts that the pretty-printer and parser use
  */
-import ast_util::*;
+
+import ast_util::operator_prec;
 
 fn expr_requires_semi_to_be_stmt(e: @ast::expr) -> bool {
     alt e.node {

src/libsyntax/parse/parser.rs

@@ -5,18 +5,21 @@ import token::{can_begin_expr, is_ident, is_plain_ident};
 import codemap::{span,fss_none};
 import util::interner;
 import ast_util::{spanned, respan, mk_sp, ident_to_path, operator_prec};
-import ast::*;
 import lexer::reader;
 import prec::{as_prec, token_to_binop};
 import attr::parser_attr;
 import common::{seq_sep_trailing_disallowed, seq_sep_trailing_allowed,
-                seq_sep_none, token_to_str};
-import common::*;//{parser_common};
+                seq_sep_none, token_to_str, parser_common};
 import dvec::{dvec, extensions};
 import vec::{push};
+import ast::*;
 
 export file_type;
 export parser;
+export parse_expr;
+export parse_pat;
+export CRATE_FILE;
+export SOURCE_FILE;
 
 // FIXME (#1893): #ast expects to find this here but it's actually
 // defined in `parse` Fixing this will be easier when we have export

src/libsyntax/print/pprust.rs

@@ -1,4 +1,3 @@
-import parse::classify::*;
 import parse::comments;
 import parse::lexer;
 import codemap::codemap;
@@ -8,6 +7,7 @@ import pp::{break_offset, word, printer,
 import diagnostic;
 import ast_util::operator_prec;
 import dvec::{dvec, extensions};
+import parse::classify::*;
 
 // The ps is stored here to prevent recursive type.
 enum ann_node {