---

yaml
---
r: 188405
b: refs/heads/tmp
c: 2417273
h: refs/heads/master
i:
  188403: 8e790c1
v: v3

Author: Manishearth

[refs]

@@ -34,5 +34,5 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 522d09dfecbeca1595f25ac58c6d0178bbd21d7d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: 3b3bb0e682c2d252e9f62dd9df5cff9552af91ad
+refs/heads/tmp: 241727326ebccd5ae40557b36f35317df25b3150
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/tmp/src/liballoc/lib.rs

@@ -73,6 +73,7 @@
 #![feature(unboxed_closures)]
 #![feature(unsafe_no_drop_flag)]
 #![feature(core)]
+#![feature(unique)]
 #![cfg_attr(test, feature(test, alloc, rustc_private))]
 #![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")),
             feature(libc))]

branches/tmp/src/libcollections/slice.rs

@@ -2176,8 +2176,8 @@ mod tests {
     fn test_connect() {
         let v: [Vec<i32>; 0] = [];
         assert_eq!(v.connect(&0), []);
-        assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
-        assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
+        assert_eq!([vec![1i], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
+        assert_eq!([vec![1i], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
 
         let v: [&[_]; 2] = [&[1], &[2, 3]];
         assert_eq!(v.connect(&0), [1, 0, 2, 3]);

branches/tmp/src/libcoretest/hash/mod.rs

@@ -86,7 +86,7 @@ struct CustomHasher { output: u64 }
 
 impl Hasher for CustomHasher {
     fn finish(&self) -> u64 { self.output }
-    fn write(&mut self, _: &[u8]) { panic!() }
+    fn write(&mut self, data: &[u8]) { panic!() }
     fn write_u64(&mut self, data: u64) { self.output = data; }
 }
 

branches/tmp/src/libcoretest/str.rs

@@ -188,13 +188,15 @@ fn trim_ws() {
 
 mod pattern {
     use std::str::Pattern;
-    use std::str::{Searcher, ReverseSearcher};
+    use std::str::{Searcher, ReverseSearcher, DoubleEndedSearcher};
     use std::str::SearchStep::{self, Match, Reject, Done};
 
     macro_rules! make_test {
         ($name:ident, $p:expr, $h:expr, [$($e:expr,)*]) => {
             mod $name {
-                use std::str::SearchStep::{Match, Reject};
+                use std::str::Pattern;
+                use std::str::{Searcher, ReverseSearcher, DoubleEndedSearcher};
+                use std::str::SearchStep::{self, Match, Reject, Done};
                 use super::{cmp_search_to_vec};
                 #[test]
                 fn fwd() {

branches/tmp/src/librand/rand_impls.rs

@@ -214,6 +214,7 @@ impl<T:Rand> Rand for Option<T> {
 
 #[cfg(test)]
 mod tests {
+    use std::prelude::v1::*;
     use std::rand::{Rng, thread_rng, Open01, Closed01};
 
     struct ConstantRng(u64);

branches/tmp/src/librbml/io.rs

@@ -140,32 +140,32 @@ mod tests {
     fn test_seekable_mem_writer() {
         let mut writer = SeekableMemWriter::new();
         assert_eq!(writer.tell(), Ok(0));
-        writer.write_all(&[0]).unwrap();
+        writer.write(&[0]).unwrap();
         assert_eq!(writer.tell(), Ok(1));
-        writer.write_all(&[1, 2, 3]).unwrap();
-        writer.write_all(&[4, 5, 6, 7]).unwrap();
+        writer.write(&[1, 2, 3]).unwrap();
+        writer.write(&[4, 5, 6, 7]).unwrap();
         assert_eq!(writer.tell(), Ok(8));
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
         writer.seek(0, old_io::SeekSet).unwrap();
         assert_eq!(writer.tell(), Ok(0));
-        writer.write_all(&[3, 4]).unwrap();
+        writer.write(&[3, 4]).unwrap();
         let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
         writer.seek(1, old_io::SeekCur).unwrap();
-        writer.write_all(&[0, 1]).unwrap();
+        writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
 
         writer.seek(-1, old_io::SeekEnd).unwrap();
-        writer.write_all(&[1, 2]).unwrap();
+        writer.write(&[1, 2]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
         assert_eq!(writer.get_ref(), b);
 
         writer.seek(1, old_io::SeekEnd).unwrap();
-        writer.write_all(&[1]).unwrap();
+        writer.write(&[1]).unwrap();
         let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
         assert_eq!(writer.get_ref(), b);
     }
@@ -174,7 +174,7 @@ mod tests {
     fn seek_past_end() {
         let mut r = SeekableMemWriter::new();
         r.seek(10, old_io::SeekSet).unwrap();
-        assert!(r.write_all(&[3]).is_ok());
+        assert!(r.write(&[3]).is_ok());
     }
 
     #[test]
@@ -190,7 +190,7 @@ mod tests {
         b.iter(|| {
             let mut wr = SeekableMemWriter::new();
             for _ in 0..times {
-                wr.write_all(&src).unwrap();
+                wr.write(&src).unwrap();
             }
 
             let v = wr.unwrap();

branches/tmp/src/librustc/metadata/common.rs

@@ -252,6 +252,3 @@ pub const tag_macro_def: uint = 0x9e;
 pub const tag_macro_def_body: uint = 0x9f;
 
 pub const tag_paren_sugar: uint = 0xa0;
-
-pub const tag_codemap: uint = 0xa1;
-pub const tag_codemap_filemap: uint = 0xa2;

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

@@ -26,7 +26,7 @@ use syntax::ast;
 use syntax::abi;
 use syntax::attr;
 use syntax::attr::AttrMetaMethods;
-use syntax::codemap::{self, Span, mk_sp, Pos};
+use syntax::codemap::{Span, mk_sp};
 use syntax::parse;
 use syntax::parse::token::InternedString;
 use syntax::parse::token;
@@ -373,17 +373,15 @@ impl<'a> CrateReader<'a> {
         // Maintain a reference to the top most crate.
         let root = if root.is_some() { root } else { &crate_paths };
 
-        let loader::Library { dylib, rlib, metadata } = lib;
+        let cnum_map = self.resolve_crate_deps(root, lib.metadata.as_slice(), span);
 
-        let cnum_map = self.resolve_crate_deps(root, metadata.as_slice(), span);
-        let codemap_import_info = import_codemap(self.sess.codemap(), &metadata);
+        let loader::Library{ dylib, rlib, metadata } = lib;
 
         let cmeta = Rc::new( cstore::crate_metadata {
             name: name.to_string(),
             data: metadata,
             cnum_map: cnum_map,
             cnum: cnum,
-            codemap_import_info: codemap_import_info,
             span: span,
         });
 
@@ -588,131 +586,3 @@ impl<'a> CrateReader<'a> {
         }
     }
 }
-
-/// Imports the codemap from an external crate into the codemap of the crate
-/// currently being compiled (the "local crate").
-///
-/// The import algorithm works analogous to how AST items are inlined from an
-/// external crate's metadata:
-/// For every FileMap in the external codemap an 'inline' copy is created in the
-/// local codemap. The correspondence relation between external and local
-/// FileMaps is recorded in the `ImportedFileMap` objects returned from this
-/// function. When an item from an external crate is later inlined into this
-/// crate, this correspondence information is used to translate the span
-/// information of the inlined item so that it refers the correct positions in
-/// the local codemap (see `astencode::DecodeContext::tr_span()`).
-///
-/// The import algorithm in the function below will reuse FileMaps already
-/// existing in the local codemap. For example, even if the FileMap of some
-/// source file of libstd gets imported many times, there will only ever be
-/// one FileMap object for the corresponding file in the local codemap.
-///
-/// Note that imported FileMaps do not actually contain the source code of the
-/// file they represent, just information about length, line breaks, and
-/// multibyte characters. This information is enough to generate valid debuginfo
-/// for items inlined from other crates.
-fn import_codemap(local_codemap: &codemap::CodeMap,
-                  metadata: &MetadataBlob)
-                  -> Vec<cstore::ImportedFileMap> {
-    let external_codemap = decoder::get_imported_filemaps(metadata.as_slice());
-
-    let imported_filemaps = external_codemap.into_iter().map(|filemap_to_import| {
-        // Try to find an existing FileMap that can be reused for the filemap to
-        // be imported. A FileMap is reusable if it is exactly the same, just
-        // positioned at a different offset within the codemap.
-        let reusable_filemap = {
-            local_codemap.files
-                         .borrow()
-                         .iter()
-                         .find(|fm| are_equal_modulo_startpos(&fm, &filemap_to_import))
-                         .map(|rc| rc.clone())
-        };
-
-        match reusable_filemap {
-            Some(fm) => {
-                cstore::ImportedFileMap {
-                    original_start_pos: filemap_to_import.start_pos,
-                    original_end_pos: filemap_to_import.end_pos,
-                    translated_filemap: fm
-                }
-            }
-            None => {
-                // We can't reuse an existing FileMap, so allocate a new one
-                // containing the information we need.
-                let codemap::FileMap {
-                    name,
-                    start_pos,
-                    end_pos,
-                    lines,
-                    multibyte_chars,
-                    ..
-                } = filemap_to_import;
-
-                let source_length = (end_pos - start_pos).to_usize();
-
-                // Translate line-start positions and multibyte character
-                // position into frame of reference local to file.
-                // `CodeMap::new_imported_filemap()` will then translate those
-                // coordinates to their new global frame of reference when the
-                // offset of the FileMap is known.
-                let lines = lines.into_inner().map_in_place(|pos| pos - start_pos);
-                let multibyte_chars = multibyte_chars
-                    .into_inner()
-                    .map_in_place(|mbc|
-                        codemap::MultiByteChar {
-                            pos: mbc.pos + start_pos,
-                            bytes: mbc.bytes
-                        });
-
-                let local_version = local_codemap.new_imported_filemap(name,
-                                                                       source_length,
-                                                                       lines,
-                                                                       multibyte_chars);
-                cstore::ImportedFileMap {
-                    original_start_pos: start_pos,
-                    original_end_pos: end_pos,
-                    translated_filemap: local_version
-                }
-            }
-        }
-    }).collect();
-
-    return imported_filemaps;
-
-    fn are_equal_modulo_startpos(fm1: &codemap::FileMap,
-                                 fm2: &codemap::FileMap)
-                                 -> bool {
-        if fm1.name != fm2.name {
-            return false;
-        }
-
-        let lines1 = fm1.lines.borrow();
-        let lines2 = fm2.lines.borrow();
-
-        if lines1.len() != lines2.len() {
-            return false;
-        }
-
-        for (&line1, &line2) in lines1.iter().zip(lines2.iter()) {
-            if (line1 - fm1.start_pos) != (line2 - fm2.start_pos) {
-                return false;
-            }
-        }
-
-        let multibytes1 = fm1.multibyte_chars.borrow();
-        let multibytes2 = fm2.multibyte_chars.borrow();
-
-        if multibytes1.len() != multibytes2.len() {
-            return false;
-        }
-
-        for (mb1, mb2) in multibytes1.iter().zip(multibytes2.iter()) {
-            if (mb1.bytes != mb2.bytes) ||
-               ((mb1.pos - fm1.start_pos) != (mb2.pos - fm2.start_pos)) {
-                return false;
-            }
-        }
-
-        true
-    }
-}

branches/tmp/src/librustc/metadata/cstore.rs

@@ -27,7 +27,7 @@ use std::cell::RefCell;
 use std::rc::Rc;
 use flate::Bytes;
 use syntax::ast;
-use syntax::codemap;
+use syntax::codemap::Span;
 use syntax::parse::token::IdentInterner;
 
 // A map from external crate numbers (as decoded from some crate file) to
@@ -41,24 +41,12 @@ pub enum MetadataBlob {
     MetadataArchive(loader::ArchiveMetadata),
 }
 
-/// Holds information about a codemap::FileMap imported from another crate.
-/// See creader::import_codemap() for more information.
-pub struct ImportedFileMap {
-    /// This FileMap's byte-offset within the codemap of its original crate
-    pub original_start_pos: codemap::BytePos,
-    /// The end of this FileMap within the codemap of its original crate
-    pub original_end_pos: codemap::BytePos,
-    /// The imported FileMap's representation within the local codemap
-    pub translated_filemap: Rc<codemap::FileMap>
-}
-
 pub struct crate_metadata {
     pub name: String,
     pub data: MetadataBlob,
     pub cnum_map: cnum_map,
     pub cnum: ast::CrateNum,
-    pub codemap_import_info: Vec<ImportedFileMap>,
-    pub span: codemap::Span,
+    pub span: Span,
 }
 
 #[derive(Copy, Debug, PartialEq, Clone)]

branches/tmp/src/librustc/metadata/decoder.rs

@@ -1561,26 +1561,11 @@ pub fn is_associated_type(cdata: Cmd, id: ast::NodeId) -> bool {
     }
 }
 
+
 pub fn is_default_trait<'tcx>(cdata: Cmd, id: ast::NodeId) -> bool {
     let item_doc = lookup_item(id, cdata.data());
     match item_family(item_doc) {
         Family::DefaultImpl => true,
         _ => false
     }
 }
-
-pub fn get_imported_filemaps(metadata: &[u8]) -> Vec<codemap::FileMap> {
-    let crate_doc = rbml::Doc::new(metadata);
-    let cm_doc = reader::get_doc(crate_doc, tag_codemap);
-
-    let mut filemaps = vec![];
-
-    reader::tagged_docs(cm_doc, tag_codemap_filemap, |filemap_doc| {
-        let mut decoder = reader::Decoder::new(filemap_doc);
-        let filemap: codemap::FileMap = Decodable::decode(&mut decoder).unwrap();
-        filemaps.push(filemap);
-        true
-    });
-
-    return filemaps;
-}