mv filemap source_file

Author: dsciarra

src/libproc_macro/lib.rs

@@ -440,9 +440,9 @@ impl SourceFile {
     /// [`is_real`]: #method.is_real
     #[unstable(feature = "proc_macro_span", issue = "38356")]
     pub fn path(&self) -> PathBuf {
-        match self.filemap.name {
+        match self.source_file.name {
             FileName::Real(ref path) => path.clone(),
-            _ => PathBuf::from(self.filemap.name.to_string())
+            _ => PathBuf::from(self.source_file.name.to_string())
         }
     }
 
@@ -453,7 +453,7 @@ impl SourceFile {
         // This is a hack until intercrate spans are implemented and we can have real source files
         // for spans generated in external macros.
         // https://github.com/rust-lang/rust/pull/43604#issuecomment-333334368
-        self.filemap.is_real_file()
+        self.source_file.is_real_file()
     }
 }
 
@@ -471,7 +471,7 @@ impl fmt::Debug for SourceFile {
 #[unstable(feature = "proc_macro_span", issue = "38356")]
 impl PartialEq for SourceFile {
     fn eq(&self, other: &Self) -> bool {
-        Lrc::ptr_eq(&self.filemap, &other.filemap)
+        Lrc::ptr_eq(&self.source_file, &other.source_file)
     }
 }
 

src/librustc/hir/map/collector.rs

@@ -158,8 +158,8 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         let mut source_file_names: Vec<_> = codemap
             .files()
             .iter()
-            .filter(|filemap| CrateNum::from_u32(filemap.crate_of_origin) == LOCAL_CRATE)
-            .map(|filemap| filemap.name_hash)
+            .filter(|source_file| CrateNum::from_u32(source_file.crate_of_origin) == LOCAL_CRATE)
+            .map(|source_file| source_file.name_hash)
             .collect();
 
         source_file_names.sort_unstable();

src/librustc/ich/caching_codemap_view.rs

@@ -79,7 +79,7 @@ impl<'cm> CachingCodemapView<'cm> {
         if pos < cache_entry.file.start_pos || pos >= cache_entry.file.end_pos {
             let file_valid;
             if self.codemap.files().len() > 0 {
-                let file_index = self.codemap.lookup_filemap_idx(pos);
+                let file_index = self.codemap.lookup_source_file_idx(pos);
                 let file = self.codemap.files()[file_index].clone();
 
                 if pos >= file.start_pos && pos < file.end_pos {

src/librustc/ich/impls_syntax.rs

@@ -458,13 +458,13 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
 
         src_hash.hash_stable(hcx, hasher);
 
-        // We only hash the relative position within this filemap
+        // We only hash the relative position within this source_file
         lines.len().hash_stable(hcx, hasher);
         for &line in lines.iter() {
             stable_byte_pos(line, start_pos).hash_stable(hcx, hasher);
         }
 
-        // We only hash the relative position within this filemap
+        // We only hash the relative position within this source_file
         multibyte_chars.len().hash_stable(hcx, hasher);
         for &char_pos in multibyte_chars.iter() {
             stable_multibyte_char(char_pos, start_pos).hash_stable(hcx, hasher);
@@ -478,29 +478,29 @@ impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
 }
 
 fn stable_byte_pos(pos: ::syntax_pos::BytePos,
-                   filemap_start: ::syntax_pos::BytePos)
+                   source_file_start: ::syntax_pos::BytePos)
                    -> u32 {
-    pos.0 - filemap_start.0
+    pos.0 - source_file_start.0
 }
 
 fn stable_multibyte_char(mbc: ::syntax_pos::MultiByteChar,
-                         filemap_start: ::syntax_pos::BytePos)
+                         source_file_start: ::syntax_pos::BytePos)
                          -> (u32, u32) {
     let ::syntax_pos::MultiByteChar {
         pos,
         bytes,
     } = mbc;
 
-    (pos.0 - filemap_start.0, bytes as u32)
+    (pos.0 - source_file_start.0, bytes as u32)
 }
 
 fn stable_non_narrow_char(swc: ::syntax_pos::NonNarrowChar,
-                          filemap_start: ::syntax_pos::BytePos)
+                          source_file_start: ::syntax_pos::BytePos)
                           -> (u32, u32) {
     let pos = swc.pos();
     let width = swc.width();
 
-    (pos.0 - filemap_start.0, width as u32)
+    (pos.0 - source_file_start.0, width as u32)
 }
 
 

src/librustc/ty/query/on_disk_cache.rs

@@ -494,7 +494,7 @@ impl<'a, 'tcx, 'x> CacheDecoder<'a, 'tcx, 'x> {
 
         file_index_to_file.borrow_mut().entry(index).or_insert_with(|| {
             let stable_id = file_index_to_stable_id[&index];
-            codemap.filemap_by_stable_id(stable_id)
+            codemap.source_file_by_stable_id(stable_id)
                    .expect("Failed to lookup SourceFile in new context.")
         }).clone()
     }
@@ -777,8 +777,8 @@ struct CacheEncoder<'enc, 'a, 'tcx, E>
 impl<'enc, 'a, 'tcx, E> CacheEncoder<'enc, 'a, 'tcx, E>
     where E: 'enc + ty_codec::TyEncoder
 {
-    fn filemap_index(&mut self, filemap: Lrc<SourceFile>) -> SourceFileIndex {
-        self.file_to_file_index[&(&*filemap as *const SourceFile)]
+    fn source_file_index(&mut self, source_file: Lrc<SourceFile>) -> SourceFileIndex {
+        self.file_to_file_index[&(&*source_file as *const SourceFile)]
     }
 
     /// Encode something with additional information that allows to do some
@@ -850,10 +850,10 @@ impl<'enc, 'a, 'tcx, E> SpecializedEncoder<Span> for CacheEncoder<'enc, 'a, 'tcx
 
         let len = span_data.hi - span_data.lo;
 
-        let filemap_index = self.filemap_index(file_lo);
+        let source_file_index = self.source_file_index(file_lo);
 
         TAG_VALID_SPAN.encode(self)?;
-        filemap_index.encode(self)?;
+        source_file_index.encode(self)?;
         line_lo.encode(self)?;
         col_lo.encode(self)?;
         len.encode(self)?;

src/librustc_driver/pretty.rs

@@ -916,7 +916,7 @@ pub fn fold_crate(sess: &Session, krate: ast::Crate, ppm: PpMode) -> ast::Crate
 fn get_source(input: &Input, sess: &Session) -> (Vec<u8>, FileName) {
     let src_name = driver::source_name(input);
     let src = sess.codemap()
-        .get_filemap(&src_name)
+        .get_source_file(&src_name)
         .unwrap()
         .src
         .as_ref()

src/librustc_errors/emitter.rs

@@ -1021,7 +1021,7 @@ impl EmitterWriter {
         // Print out the annotate source lines that correspond with the error
         for annotated_file in annotated_files {
             // we can't annotate anything if the source is unavailable.
-            if !cm.ensure_filemap_source_present(annotated_file.file.clone()) {
+            if !cm.ensure_source_file_source_present(annotated_file.file.clone()) {
                 continue;
             }
 

src/librustc_errors/lib.rs

@@ -120,7 +120,7 @@ pub trait SourceMapper {
     fn span_to_filename(&self, sp: Span) -> FileName;
     fn merge_spans(&self, sp_lhs: Span, sp_rhs: Span) -> Option<Span>;
     fn call_span_if_macro(&self, sp: Span) -> Span;
-    fn ensure_filemap_source_present(&self, file_map: Lrc<SourceFile>) -> bool;
+    fn ensure_source_file_source_present(&self, file_map: Lrc<SourceFile>) -> bool;
     fn doctest_offset_line(&self, line: usize) -> usize;
 }
 

src/librustc_metadata/cstore.rs

@@ -42,14 +42,14 @@ pub use rustc_data_structures::sync::MetadataRef;
 pub struct MetadataBlob(pub MetadataRef);
 
 /// Holds information about a syntax_pos::SourceFile imported from another crate.
-/// See `imported_filemaps()` for more information.
+/// See `imported_source_files()` for more information.
 pub struct ImportedSourceFile {
     /// This SourceFile's byte-offset within the codemap of its original crate
     pub original_start_pos: syntax_pos::BytePos,
     /// The end of this SourceFile within the codemap of its original crate
     pub original_end_pos: syntax_pos::BytePos,
     /// The imported SourceFile's representation within the local codemap
-    pub translated_filemap: Lrc<syntax_pos::SourceFile>,
+    pub translated_source_file: Lrc<syntax_pos::SourceFile>,
 }
 
 pub struct CrateMetadata {

src/librustc_metadata/cstore_impl.rs

@@ -40,7 +40,7 @@ use syntax::ast;
 use syntax::attr;
 use syntax::codemap;
 use syntax::edition::Edition;
-use syntax::parse::filemap_to_stream;
+use syntax::parse::source_file_to_stream;
 use syntax::symbol::Symbol;
 use syntax_pos::{Span, NO_EXPANSION, FileName};
 use rustc_data_structures::indexed_set::IdxSetBuf;
@@ -463,9 +463,9 @@ impl cstore::CStore {
         let (name, def) = data.get_macro(id.index);
         let source_name = FileName::Macros(name.to_string());
 
-        let filemap = sess.parse_sess.codemap().new_filemap(source_name, def.body);
-        let local_span = Span::new(filemap.start_pos, filemap.end_pos, NO_EXPANSION);
-        let body = filemap_to_stream(&sess.parse_sess, filemap, None);
+        let source_file = sess.parse_sess.codemap().new_source_file(source_name, def.body);
+        let local_span = Span::new(source_file.start_pos, source_file.end_pos, NO_EXPANSION);
+        let body = source_file_to_stream(&sess.parse_sess, source_file, None);
 
         // Mark the attrs as used
         let attrs = data.get_item_attrs(id.index, sess);

src/librustc_metadata/decoder.rs

@@ -50,8 +50,8 @@ pub struct DecodeContext<'a, 'tcx: 'a> {
     sess: Option<&'a Session>,
     tcx: Option<TyCtxt<'a, 'tcx, 'tcx>>,
 
-    // Cache the last used filemap for translating spans as an optimization.
-    last_filemap_index: usize,
+    // Cache the last used source_file for translating spans as an optimization.
+    last_source_file_index: usize,
 
     lazy_state: LazyState,
 
@@ -73,7 +73,7 @@ pub trait Metadata<'a, 'tcx>: Copy {
             cdata: self.cdata(),
             sess: self.sess().or(tcx.map(|tcx| tcx.sess)),
             tcx,
-            last_filemap_index: 0,
+            last_source_file_index: 0,
             lazy_state: LazyState::NoNode,
             alloc_decoding_session: self.cdata().map(|cdata| {
                 cdata.alloc_decoding_state.new_decoding_session()
@@ -314,43 +314,43 @@ impl<'a, 'tcx> SpecializedDecoder<Span> for DecodeContext<'a, 'tcx> {
             bug!("Cannot decode Span without Session.")
         };
 
-        let imported_filemaps = self.cdata().imported_filemaps(&sess.codemap());
-        let filemap = {
+        let imported_source_files = self.cdata().imported_source_files(&sess.codemap());
+        let source_file = {
             // Optimize for the case that most spans within a translated item
-            // originate from the same filemap.
-            let last_filemap = &imported_filemaps[self.last_filemap_index];
+            // originate from the same source_file.
+            let last_source_file = &imported_source_files[self.last_source_file_index];
 
-            if lo >= last_filemap.original_start_pos &&
-               lo <= last_filemap.original_end_pos {
-                last_filemap
+            if lo >= last_source_file.original_start_pos &&
+               lo <= last_source_file.original_end_pos {
+                last_source_file
             } else {
                 let mut a = 0;
-                let mut b = imported_filemaps.len();
+                let mut b = imported_source_files.len();
 
                 while b - a > 1 {
                     let m = (a + b) / 2;
-                    if imported_filemaps[m].original_start_pos > lo {
+                    if imported_source_files[m].original_start_pos > lo {
                         b = m;
                     } else {
                         a = m;
                     }
                 }
 
-                self.last_filemap_index = a;
-                &imported_filemaps[a]
+                self.last_source_file_index = a;
+                &imported_source_files[a]
             }
         };
 
         // Make sure our binary search above is correct.
-        debug_assert!(lo >= filemap.original_start_pos &&
-                      lo <= filemap.original_end_pos);
+        debug_assert!(lo >= source_file.original_start_pos &&
+                      lo <= source_file.original_end_pos);
 
         // Make sure we correctly filtered out invalid spans during encoding
-        debug_assert!(hi >= filemap.original_start_pos &&
-                      hi <= filemap.original_end_pos);
+        debug_assert!(hi >= source_file.original_start_pos &&
+                      hi <= source_file.original_end_pos);
 
-        let lo = (lo + filemap.translated_filemap.start_pos) - filemap.original_start_pos;
-        let hi = (hi + filemap.translated_filemap.start_pos) - filemap.original_start_pos;
+        let lo = (lo + source_file.translated_source_file.start_pos) - source_file.original_start_pos;
+        let hi = (hi + source_file.translated_source_file.start_pos) - source_file.original_start_pos;
 
         Ok(Span::new(lo, hi, NO_EXPANSION))
     }
@@ -1116,13 +1116,13 @@ impl<'a, 'tcx> CrateMetadata {
     /// 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.
-    pub fn imported_filemaps(&'a self,
+    pub fn imported_source_files(&'a self,
                              local_codemap: &codemap::SourceMap)
                              -> ReadGuard<'a, Vec<cstore::ImportedSourceFile>> {
         {
-            let filemaps = self.codemap_import_info.borrow();
-            if !filemaps.is_empty() {
-                return filemaps;
+            let source_files = self.codemap_import_info.borrow();
+            if !source_files.is_empty() {
+                return source_files;
             }
         }
 
@@ -1136,7 +1136,7 @@ impl<'a, 'tcx> CrateMetadata {
 
         let external_codemap = self.root.codemap.decode(self);
 
-        let imported_filemaps = external_codemap.map(|filemap_to_import| {
+        let imported_source_files = external_codemap.map(|source_file_to_import| {
             // We can't reuse an existing SourceFile, so allocate a new one
             // containing the information we need.
             let syntax_pos::SourceFile { name,
@@ -1148,13 +1148,13 @@ impl<'a, 'tcx> CrateMetadata {
                                       mut multibyte_chars,
                                       mut non_narrow_chars,
                                       name_hash,
-                                      .. } = filemap_to_import;
+                                      .. } = source_file_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.
-            // `SourceMap::new_imported_filemap()` will then translate those
+            // `SourceMap::new_imported_source_file()` will then translate those
             // coordinates to their new global frame of reference when the
             // offset of the SourceFile is known.
             for pos in &mut lines {
@@ -1167,7 +1167,7 @@ impl<'a, 'tcx> CrateMetadata {
                 *swc = *swc - start_pos;
             }
 
-            let local_version = local_codemap.new_imported_filemap(name,
+            let local_version = local_codemap.new_imported_source_file(name,
                                                                    name_was_remapped,
                                                                    self.cnum.as_u32(),
                                                                    src_hash,
@@ -1176,20 +1176,20 @@ impl<'a, 'tcx> CrateMetadata {
                                                                    lines,
                                                                    multibyte_chars,
                                                                    non_narrow_chars);
-            debug!("CrateMetaData::imported_filemaps alloc \
-                    filemap {:?} original (start_pos {:?} end_pos {:?}) \
+            debug!("CrateMetaData::imported_source_files alloc \
+                    source_file {:?} original (start_pos {:?} end_pos {:?}) \
                     translated (start_pos {:?} end_pos {:?})",
                    local_version.name, start_pos, end_pos,
                    local_version.start_pos, local_version.end_pos);
 
             cstore::ImportedSourceFile {
                 original_start_pos: start_pos,
                 original_end_pos: end_pos,
-                translated_filemap: local_version,
+                translated_source_file: local_version,
             }
         }).collect();
 
-        *codemap_import_info = imported_filemaps;
+        *codemap_import_info = imported_source_files;
         drop(codemap_import_info);
 
         // This shouldn't borrow twice, but there is no way to downgrade RefMut to Ref.