---

yaml
---
r: 35061
b: refs/heads/master
c: 37ed7fc
h: refs/heads/master
i:
  35059: b6a1e3d
v: v3

Author: Brian J. Burg

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 15a5d2ccbf2de7ac0bb4894a6885791fa1f23521
+refs/heads/master: 37ed7fcaae1477cd85985886b5f8a4514bf98d0e
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
 refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024

trunk/src/libcore/option.rs

@@ -87,7 +87,7 @@ pub pure fn get_ref<T>(opt: &r/Option<T>) -> &r/T {
 
 pub pure fn expect<T>(opt: Option<T>, reason: ~str) -> T {
     /*!
-     * Gets the value out of an option without copying, printing a
+     * Gets the value out of an option without copying, printing a 
      * specified message on failure.
      *
      * # Failure

trunk/src/libcore/result.rs

@@ -103,11 +103,11 @@ pub pure fn to_either<T: Copy, U: Copy>(res: &Result<U, T>)
  *         ok(parse_bytes(buf))
  *     }
  */
-pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
+pub fn chain<T, U, V>(res: Result<T, V>, op: fn(t: T)
     -> Result<U, V>) -> Result<U, V> {
     match move res {
         Ok(move t) => op(move t),
-        Err(move e) => Err(e)
+        Err(move e) => Err(move e)
     }
 }
 
@@ -119,13 +119,13 @@ pub fn chain<T, U: Copy, V: Copy>(res: Result<T, V>, op: fn(t: T)
  * immediately returned.  This function can be used to pass through a
  * successful result while handling an error.
  */
-pub fn chain_err<T: Copy, U: Copy, V: Copy>(
+pub fn chain_err<T, U, V>(
     res: Result<T, V>,
     op: fn(t: V) -> Result<T, U>)
     -> Result<T, U> {
     match move res {
-      Ok(move t) => Ok(t),
-      Err(move v) => op(v)
+      Ok(move t) => Ok(move t),
+      Err(move v) => op(move v)
     }
 }
 

trunk/src/libfuzzer/fuzzer.rs

@@ -225,7 +225,7 @@ fn as_str(f: fn@(+x: io::Writer)) -> ~str {
     io::with_str_writer(f)
 }
 
-fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
+fn check_variants_of_ast(crate: ast::crate, codemap: codemap::CodeMap,
                          filename: &Path, cx: context) {
     let stolen = steal(crate, cx.mode);
     let extra_exprs = vec::filter(common_exprs(),
@@ -239,7 +239,7 @@ fn check_variants_of_ast(crate: ast::crate, codemap: @codemap::CodeMap,
 
 fn check_variants_T<T: Copy>(
   crate: ast::crate,
-  codemap: @codemap::CodeMap,
+  codemap: codemap::CodeMap,
   filename: &Path,
   thing_label: ~str,
   things: ~[T],

trunk/src/librustc/driver/driver.rs

@@ -574,7 +574,7 @@ fn build_session_options(binary: ~str,
 
 fn build_session(sopts: @session::options,
                  demitter: diagnostic::emitter) -> Session {
-    let codemap = @codemap::new_codemap();
+    let codemap = codemap::new_codemap();
     let diagnostic_handler =
         diagnostic::mk_handler(Some(demitter));
     let span_diagnostic_handler =
@@ -583,7 +583,7 @@ fn build_session(sopts: @session::options,
 }
 
 fn build_session_(sopts: @session::options,
-                  cm: @codemap::CodeMap,
+                  cm: codemap::CodeMap,
                   demitter: diagnostic::emitter,
                   span_diagnostic_handler: diagnostic::span_handler)
                -> Session {

trunk/src/librustc/driver/session.rs

@@ -131,7 +131,7 @@ type Session_ = {targ_cfg: @config,
                  opts: @options,
                  cstore: metadata::cstore::CStore,
                  parse_sess: parse_sess,
-                 codemap: @codemap::CodeMap,
+                 codemap: codemap::CodeMap,
                  // For a library crate, this is always none
                  mut main_fn: Option<(node_id, codemap::span)>,
                  span_diagnostic: diagnostic::span_handler,

trunk/src/librustc/metadata/csearch.rs

@@ -63,10 +63,7 @@ fn get_type_param_count(cstore: cstore::CStore, def: ast::def_id) -> uint {
 fn each_path(cstore: cstore::CStore, cnum: ast::crate_num,
              f: fn(decoder::path_entry) -> bool) {
     let crate_data = cstore::get_crate_data(cstore, cnum);
-    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
-        cstore::get_crate_data(cstore, cnum)
-    };
-    decoder::each_path(cstore.intr, crate_data, get_crate_data, f);
+    decoder::each_path(cstore.intr, crate_data, f);
 }
 
 fn get_item_path(tcx: ty::ctxt, def: ast::def_id) -> ast_map::path {

trunk/src/librustc/metadata/cstore.rs

@@ -98,11 +98,7 @@ fn get_crate_vers(cstore: CStore, cnum: ast::crate_num) -> ~str {
 fn set_crate_data(cstore: CStore, cnum: ast::crate_num,
                   data: crate_metadata) {
     p(cstore).metas.insert(cnum, data);
-    let get_crate_data: decoder::GetCrateDataCb = |cnum| {
-        cstore::get_crate_data(cstore, cnum)
-    };
-    for vec::each(decoder::get_crate_module_paths(cstore.intr, data,
-                                                  get_crate_data)) |dp| {
+    for vec::each(decoder::get_crate_module_paths(cstore.intr, data)) |dp| {
         let (did, path) = *dp;
         let d = {crate: cnum, node: did.node};
         p(cstore).mod_path_map.insert(d, @path);

trunk/src/librustc/metadata/decoder.rs

@@ -60,7 +60,6 @@ export item_type; // sketchy
 export maybe_get_item_ast;
 export decode_inlined_item;
 export method_info, _impl;
-export GetCrateDataCb;
 
 // Used internally by astencode:
 export translate_def_id;
@@ -89,8 +88,6 @@ fn lookup_hash(d: ebml::Doc, eq_fn: fn(x:&[u8]) -> bool, hash: uint) ->
     None
 }
 
-pub type GetCrateDataCb = &fn(ast::crate_num) -> cmd;
-
 fn maybe_find_item(item_id: int, items: ebml::Doc) -> Option<ebml::Doc> {
     fn eq_item(bytes: &[u8], item_id: int) -> bool {
         return io::u64_from_be_bytes(vec::view(bytes, 0u, 4u), 0u, 4u) as int
@@ -480,9 +477,7 @@ fn path_entry(path_string: ~str, def_like: def_like) -> path_entry {
 }
 
 /// Iterates over all the paths in the given crate.
-fn each_path(intr: @ident_interner, cdata: cmd,
-             get_crate_data: GetCrateDataCb,
-             f: fn(path_entry) -> bool) {
+fn each_path(intr: @ident_interner, cdata: cmd, f: fn(path_entry) -> bool) {
     let root = ebml::Doc(cdata.data);
     let items = ebml::get_doc(root, tag_items);
     let items_data = ebml::get_doc(items, tag_items_data);
@@ -531,17 +526,8 @@ fn each_path(intr: @ident_interner, cdata: cmd,
                         reexport_path = path + ~"::" + reexport_name;
                     }
 
-                    // This reexport may be in yet another crate
-                    let other_crates_items = if def_id.crate == cdata.cnum {
-                        items
-                    } else {
-                        let crate_data = get_crate_data(def_id.crate);
-                        let root = ebml::Doc(crate_data.data);
-                        ebml::get_doc(root, tag_items)
-                    };
-
                     // Get the item.
-                    match maybe_find_item(def_id.node, other_crates_items) {
+                    match maybe_find_item(def_id.node, items) {
                         None => {}
                         Some(item_doc) => {
                             // Construct the def for this item.
@@ -1093,10 +1079,9 @@ fn get_crate_vers(data: @~[u8]) -> ~str {
     };
 }
 
-fn iter_crate_items(intr: @ident_interner, cdata: cmd,
-                    get_crate_data: GetCrateDataCb,
-                    proc: fn(~str, ast::def_id)) {
-    for each_path(intr, cdata, get_crate_data) |path_entry| {
+fn iter_crate_items(intr: @ident_interner,
+                    cdata: cmd, proc: fn(~str, ast::def_id)) {
+    for each_path(intr, cdata) |path_entry| {
         match path_entry.def_like {
             dl_impl(*) | dl_field => {}
             dl_def(def) => {
@@ -1106,8 +1091,7 @@ fn iter_crate_items(intr: @ident_interner, cdata: cmd,
     }
 }
 
-fn get_crate_module_paths(intr: @ident_interner, cdata: cmd,
-                          get_crate_data: GetCrateDataCb)
+fn get_crate_module_paths(intr: @ident_interner, cdata: cmd)
                                     -> ~[(ast::def_id, ~str)] {
     fn mod_of_path(p: ~str) -> ~str {
         str::connect(vec::init(str::split_str(p, ~"::")), ~"::")
@@ -1117,7 +1101,7 @@ fn get_crate_module_paths(intr: @ident_interner, cdata: cmd,
     // fowarded path due to renamed import or reexport
     let mut res = ~[];
     let mods = map::HashMap();
-    do iter_crate_items(intr, cdata, get_crate_data) |path, did| {
+    do iter_crate_items(intr, cdata) |path, did| {
         let m = mod_of_path(path);
         if str::is_not_empty(m) {
             // if m has a sub-item, it must be a module

trunk/src/librustc/middle/trans/base.rs

@@ -2436,10 +2436,7 @@ fn gather_local_rtcalls(ccx: @crate_ctxt, crate: @ast::crate) {
 
 fn gather_external_rtcalls(ccx: @crate_ctxt) {
     do cstore::iter_crate_data(ccx.sess.cstore) |_cnum, cmeta| {
-        let get_crate_data: decoder::GetCrateDataCb = |cnum| {
-            cstore::get_crate_data(ccx.sess.cstore, cnum)
-        };
-        do decoder::each_path(ccx.sess.intr(), cmeta, get_crate_data) |path| {
+        do decoder::each_path(ccx.sess.intr(), cmeta) |path| {
             let pathname = path.path_string;
             match path.def_like {
               decoder::dl_def(d) => {

trunk/src/librustc/middle/trans/debuginfo.rs

@@ -229,7 +229,7 @@ fn create_file(cx: @crate_ctxt, full_path: ~str) -> @metadata<file_md> {
     return mdval;
 }
 
-fn line_from_span(cm: @codemap::CodeMap, sp: span) -> uint {
+fn line_from_span(cm: codemap::CodeMap, sp: span) -> uint {
     codemap::lookup_char_pos(cm, sp.lo).line
 }
 

trunk/src/librustc/rustc.rs

@@ -193,7 +193,7 @@ fn monitor(+f: fn~(diagnostic::emitter)) {
 
         // The 'diagnostics emitter'. Every error, warning, etc. should
         // go through this function.
-        let demitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
+        let demitter = fn@(cmsp: Option<(codemap::CodeMap, codemap::span)>,
                            msg: &str, lvl: diagnostic::level) {
             if lvl == diagnostic::fatal {
                 comm::send(ch, fatal);

trunk/src/librustdoc/astsrv.rs

@@ -120,7 +120,7 @@ fn build_ctxt(sess: Session,
 
 fn build_session() -> Session {
     let sopts: @options = basic_options();
-    let codemap = @codemap::new_codemap();
+    let codemap = codemap::new_codemap();
     let error_handlers = build_error_handlers(codemap);
     let {emitter, span_handler} = error_handlers;
 
@@ -137,7 +137,7 @@ type ErrorHandlers = {
 // Build a custom error handler that will allow us to ignore non-fatal
 // errors
 fn build_error_handlers(
-    codemap: @codemap::CodeMap
+    codemap: codemap::CodeMap
 ) -> ErrorHandlers {
 
     type DiagnosticHandler = {
@@ -156,13 +156,13 @@ fn build_error_handlers(
         fn note(msg: &str) { self.inner.note(msg) }
         fn bug(msg: &str) -> ! { self.inner.bug(msg) }
         fn unimpl(msg: &str) -> ! { self.inner.unimpl(msg) }
-        fn emit(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
+        fn emit(cmsp: Option<(codemap::CodeMap, codemap::span)>,
                 msg: &str, lvl: diagnostic::level) {
             self.inner.emit(cmsp, msg, lvl)
         }
     }
 
-    let emitter = fn@(cmsp: Option<(@codemap::CodeMap, codemap::span)>,
+    let emitter = fn@(cmsp: Option<(codemap::CodeMap, codemap::span)>,
                        msg: &str, lvl: diagnostic::level) {
         diagnostic::emit(cmsp, msg, lvl);
     };

trunk/src/libstd/net_tcp.rs

@@ -1586,7 +1586,7 @@ mod test {
         // client
         log(debug, ~"server started, firing up client..");
         let server_addr = ip::v4::parse_addr(server_ip);
-        let conn_result = connect(move server_addr, server_port, hl_loop);
+        let conn_result = connect(server_addr, server_port, hl_loop);
         if result::is_err(&conn_result) {
             assert false;
         }

trunk/src/libsyntax/ast_util.rs

@@ -15,7 +15,7 @@ pure fn dummy_spanned<T>(+t: T) -> spanned<T> {
 
 /* assuming that we're not in macro expansion */
 pure fn mk_sp(lo: uint, hi: uint) -> span {
-    span {lo: lo, hi: hi, expn_info: None}
+    {lo: lo, hi: hi, expn_info: None}
 }
 
 // make this a const, once the compiler supports it