mv codemap source_map

Author: dsciarra

src/librustc/hir/map/collector.rs

@@ -122,7 +122,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
     pub(super) fn finalize_and_compute_crate_hash(mut self,
                                                   crate_disambiguator: CrateDisambiguator,
                                                   cstore: &dyn CrateStore,
-                                                  codemap: &SourceMap,
+                                                  source_map: &SourceMap,
                                                   commandline_args_hash: u64)
                                                   -> (Vec<MapEntry<'hir>>, Svh) {
         self
@@ -155,7 +155,7 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> {
         // If we included the full mapping in the SVH, we could only have
         // reproducible builds by compiling from the same directory. So we just
         // hash the result of the mapping instead of the mapping itself.
-        let mut source_file_names: Vec<_> = codemap
+        let mut source_file_names: Vec<_> = source_map
             .files()
             .iter()
             .filter(|source_file| CrateNum::from_u32(source_file.crate_of_origin) == LOCAL_CRATE)

src/librustc/ich/caching_codemap_view.rs

@@ -24,14 +24,14 @@ struct CacheEntry {
 
 #[derive(Clone)]
 pub struct CachingCodemapView<'cm> {
-    codemap: &'cm SourceMap,
+    source_map: &'cm SourceMap,
     line_cache: [CacheEntry; 3],
     time_stamp: usize,
 }
 
 impl<'cm> CachingCodemapView<'cm> {
-    pub fn new(codemap: &'cm SourceMap) -> CachingCodemapView<'cm> {
-        let files = codemap.files();
+    pub fn new(source_map: &'cm SourceMap) -> CachingCodemapView<'cm> {
+        let files = source_map.files();
         let first_file = files[0].clone();
         let entry = CacheEntry {
             time_stamp: 0,
@@ -43,7 +43,7 @@ impl<'cm> CachingCodemapView<'cm> {
         };
 
         CachingCodemapView {
-            codemap,
+            source_map,
             line_cache: [entry.clone(), entry.clone(), entry.clone()],
             time_stamp: 0,
         }
@@ -78,9 +78,9 @@ impl<'cm> CachingCodemapView<'cm> {
         // If the entry doesn't point to the correct file, fix it up
         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_source_file_idx(pos);
-                let file = self.codemap.files()[file_index].clone();
+            if self.source_map.files().len() > 0 {
+                let file_index = self.source_map.lookup_source_file_idx(pos);
+                let file = self.source_map.files()[file_index].clone();
 
                 if pos >= file.start_pos && pos < file.end_pos {
                     cache_entry.file = file;

src/librustc/ich/hcx.rs

@@ -58,8 +58,8 @@ pub struct StableHashingContext<'a> {
 
     // Very often, we are hashing something that does not need the
     // CachingCodemapView, so we initialize it lazily.
-    raw_codemap: &'a SourceMap,
-    caching_codemap: Option<CachingCodemapView<'a>>,
+    raw_source_map: &'a SourceMap,
+    caching_source_map: Option<CachingCodemapView<'a>>,
 
     pub(super) alloc_id_recursion_tracker: FxHashSet<AllocId>,
 }
@@ -100,8 +100,8 @@ impl<'a> StableHashingContext<'a> {
             body_resolver: BodyResolver(krate),
             definitions,
             cstore,
-            caching_codemap: None,
-            raw_codemap: sess.source_map(),
+            caching_source_map: None,
+            raw_source_map: sess.source_map(),
             hash_spans: hash_spans_initial,
             hash_bodies: true,
             node_id_hashing_mode: NodeIdHashingMode::HashDefPath,
@@ -170,12 +170,12 @@ impl<'a> StableHashingContext<'a> {
 
     #[inline]
     pub fn source_map(&mut self) -> &mut CachingCodemapView<'a> {
-        match self.caching_codemap {
+        match self.caching_source_map {
             Some(ref mut cm) => {
                 cm
             }
             ref mut none => {
-                *none = Some(CachingCodemapView::new(self.raw_codemap));
+                *none = Some(CachingCodemapView::new(self.raw_source_map));
                 none.as_mut().unwrap()
             }
         }

src/librustc/session/mod.rs

@@ -980,7 +980,7 @@ pub fn build_session(
 ) -> Session {
     let file_path_mapping = sopts.file_path_mapping();
 
-    build_session_with_codemap(
+    build_session_with_source_map(
         sopts,
         local_crate_source_file,
         registry,
@@ -989,11 +989,11 @@ pub fn build_session(
     )
 }
 
-pub fn build_session_with_codemap(
+pub fn build_session_with_source_map(
     sopts: config::Options,
     local_crate_source_file: Option<PathBuf>,
     registry: errors::registry::Registry,
-    codemap: Lrc<source_map::SourceMap>,
+    source_map: Lrc<source_map::SourceMap>,
     emitter_dest: Option<Box<dyn Write + Send>>,
 ) -> Session {
     // FIXME: This is not general enough to make the warning lint completely override
@@ -1020,35 +1020,35 @@ pub fn build_session_with_codemap(
             (config::ErrorOutputType::HumanReadable(color_config), None) => Box::new(
                 EmitterWriter::stderr(
                     color_config,
-                    Some(codemap.clone()),
+                    Some(source_map.clone()),
                     false,
                     sopts.debugging_opts.teach,
                 ).ui_testing(sopts.debugging_opts.ui_testing),
             ),
             (config::ErrorOutputType::HumanReadable(_), Some(dst)) => Box::new(
-                EmitterWriter::new(dst, Some(codemap.clone()), false, false)
+                EmitterWriter::new(dst, Some(source_map.clone()), false, false)
                     .ui_testing(sopts.debugging_opts.ui_testing),
             ),
             (config::ErrorOutputType::Json(pretty), None) => Box::new(
                 JsonEmitter::stderr(
                     Some(registry),
-                    codemap.clone(),
+                    source_map.clone(),
                     pretty,
                 ).ui_testing(sopts.debugging_opts.ui_testing),
             ),
             (config::ErrorOutputType::Json(pretty), Some(dst)) => Box::new(
                 JsonEmitter::new(
                     dst,
                     Some(registry),
-                    codemap.clone(),
+                    source_map.clone(),
                     pretty,
                 ).ui_testing(sopts.debugging_opts.ui_testing),
             ),
             (config::ErrorOutputType::Short(color_config), None) => Box::new(
-                EmitterWriter::stderr(color_config, Some(codemap.clone()), true, false),
+                EmitterWriter::stderr(color_config, Some(source_map.clone()), true, false),
             ),
             (config::ErrorOutputType::Short(_), Some(dst)) => {
-                Box::new(EmitterWriter::new(dst, Some(codemap.clone()), true, false))
+                Box::new(EmitterWriter::new(dst, Some(source_map.clone()), true, false))
             }
         };
 
@@ -1063,14 +1063,14 @@ pub fn build_session_with_codemap(
         },
     );
 
-    build_session_(sopts, local_crate_source_file, diagnostic_handler, codemap)
+    build_session_(sopts, local_crate_source_file, diagnostic_handler, source_map)
 }
 
 pub fn build_session_(
     sopts: config::Options,
     local_crate_source_file: Option<PathBuf>,
     span_diagnostic: errors::Handler,
-    codemap: Lrc<source_map::SourceMap>,
+    source_map: Lrc<source_map::SourceMap>,
 ) -> Session {
     let host_triple = TargetTriple::from_triple(config::host_triple());
     let host = match Target::search(&host_triple) {
@@ -1083,7 +1083,7 @@ pub fn build_session_(
     };
     let target_cfg = config::build_target_config(&sopts, &span_diagnostic);
 
-    let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap);
+    let p_s = parse::ParseSess::with_span_handler(span_diagnostic, source_map);
     let default_sysroot = match sopts.maybe_sysroot {
         Some(_) => None,
         None => Some(filesearch::get_or_default_sysroot()),

src/librustc/ty/query/on_disk_cache.rs

@@ -62,7 +62,7 @@ pub struct OnDiskCache<'sess> {
     prev_cnums: Vec<(u32, String, CrateDisambiguator)>,
     cnum_map: Once<IndexVec<CrateNum, Option<CrateNum>>>,
 
-    codemap: &'sess SourceMap,
+    source_map: &'sess SourceMap,
     file_index_to_stable_id: FxHashMap<SourceFileIndex, StableFilemapId>,
 
     // These two fields caches that are populated lazily during decoding.
@@ -140,7 +140,7 @@ impl<'sess> OnDiskCache<'sess> {
             file_index_to_file: Lock::new(FxHashMap()),
             prev_cnums: footer.prev_cnums,
             cnum_map: Once::new(),
-            codemap: sess.source_map(),
+            source_map: sess.source_map(),
             current_diagnostics: Lock::new(FxHashMap()),
             query_result_index: footer.query_result_index.into_iter().collect(),
             prev_diagnostics_index: footer.diagnostics_index.into_iter().collect(),
@@ -149,14 +149,14 @@ impl<'sess> OnDiskCache<'sess> {
         }
     }
 
-    pub fn new_empty(codemap: &'sess SourceMap) -> OnDiskCache<'sess> {
+    pub fn new_empty(source_map: &'sess SourceMap) -> OnDiskCache<'sess> {
         OnDiskCache {
             serialized_data: Vec::new(),
             file_index_to_stable_id: FxHashMap(),
             file_index_to_file: Lock::new(FxHashMap()),
             prev_cnums: vec![],
             cnum_map: Once::new(),
-            codemap,
+            source_map,
             current_diagnostics: Lock::new(FxHashMap()),
             query_result_index: FxHashMap(),
             prev_diagnostics_index: FxHashMap(),
@@ -196,7 +196,7 @@ impl<'sess> OnDiskCache<'sess> {
                 expn_info_shorthands: FxHashMap(),
                 interpret_allocs: FxHashMap(),
                 interpret_allocs_inverse: Vec::new(),
-                codemap: CachingCodemapView::new(tcx.sess.source_map()),
+                source_map: CachingCodemapView::new(tcx.sess.source_map()),
                 file_to_file_index,
             };
 
@@ -413,7 +413,7 @@ impl<'sess> OnDiskCache<'sess> {
         let mut decoder = CacheDecoder {
             tcx,
             opaque: opaque::Decoder::new(&self.serialized_data[..], pos.to_usize()),
-            codemap: self.codemap,
+            source_map: self.source_map,
             cnum_map: self.cnum_map.get(),
             file_index_to_file: &self.file_index_to_file,
             file_index_to_stable_id: &self.file_index_to_stable_id,
@@ -475,7 +475,7 @@ impl<'sess> OnDiskCache<'sess> {
 struct CacheDecoder<'a, 'tcx: 'a, 'x> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
     opaque: opaque::Decoder<'x>,
-    codemap: &'x SourceMap,
+    source_map: &'x SourceMap,
     cnum_map: &'x IndexVec<CrateNum, Option<CrateNum>>,
     synthetic_expansion_infos: &'x Lock<FxHashMap<AbsoluteBytePos, SyntaxContext>>,
     file_index_to_file: &'x Lock<FxHashMap<SourceFileIndex, Lrc<SourceFile>>>,
@@ -488,13 +488,13 @@ impl<'a, 'tcx, 'x> CacheDecoder<'a, 'tcx, 'x> {
         let CacheDecoder {
             ref file_index_to_file,
             ref file_index_to_stable_id,
-            ref codemap,
+            ref source_map,
             ..
         } = *self;
 
         file_index_to_file.borrow_mut().entry(index).or_insert_with(|| {
             let stable_id = file_index_to_stable_id[&index];
-            codemap.source_file_by_stable_id(stable_id)
+            source_map.source_file_by_stable_id(stable_id)
                    .expect("Failed to lookup SourceFile in new context.")
         }).clone()
     }
@@ -770,7 +770,7 @@ struct CacheEncoder<'enc, 'a, 'tcx, E>
     expn_info_shorthands: FxHashMap<Mark, AbsoluteBytePos>,
     interpret_allocs: FxHashMap<interpret::AllocId, usize>,
     interpret_allocs_inverse: Vec<interpret::AllocId>,
-    codemap: CachingCodemapView<'tcx>,
+    source_map: CachingCodemapView<'tcx>,
     file_to_file_index: FxHashMap<*const SourceFile, SourceFileIndex>,
 }
 
@@ -836,7 +836,7 @@ impl<'enc, 'a, 'tcx, E> SpecializedEncoder<Span> for CacheEncoder<'enc, 'a, 'tcx
             return TAG_INVALID_SPAN.encode(self);
         }
 
-        let (file_lo, line_lo, col_lo) = match self.codemap
+        let (file_lo, line_lo, col_lo) = match self.source_map
                                                    .byte_pos_to_line_and_col(span_data.lo) {
             Some(pos) => pos,
             None => {

src/librustc_driver/lib.rs

@@ -522,9 +522,9 @@ fn run_compiler_with_pool<'a>(
     };
 
     let loader = file_loader.unwrap_or(box RealFileLoader);
-    let codemap = Lrc::new(SourceMap::with_file_loader(loader, sopts.file_path_mapping()));
-    let mut sess = session::build_session_with_codemap(
-        sopts, input_file_path.clone(), descriptions, codemap, emitter_dest,
+    let source_map = Lrc::new(SourceMap::with_file_loader(loader, sopts.file_path_mapping()));
+    let mut sess = session::build_session_with_source_map(
+        sopts, input_file_path.clone(), descriptions, source_map, emitter_dest,
     );
 
     if let Some(err) = input_err {

src/librustc_metadata/creader.rs

@@ -245,7 +245,7 @@ impl<'a> CrateLoader<'a> {
             cnum_map,
             cnum,
             dependencies: Lock::new(dependencies),
-            codemap_import_info: RwLock::new(vec![]),
+            source_map_import_info: RwLock::new(vec![]),
             alloc_decoding_state: AllocDecodingState::new(interpret_alloc_index),
             dep_kind: Lock::new(dep_kind),
             source: cstore::CrateSource {

src/librustc_metadata/cstore.rs

@@ -44,11 +44,11 @@ pub struct MetadataBlob(pub MetadataRef);
 /// Holds information about a syntax_pos::SourceFile imported from another crate.
 /// See `imported_source_files()` for more information.
 pub struct ImportedSourceFile {
-    /// This SourceFile's byte-offset within the codemap of its original crate
+    /// This SourceFile's byte-offset within the source_map of its original crate
     pub original_start_pos: syntax_pos::BytePos,
-    /// The end of this SourceFile within the codemap of its original crate
+    /// The end of this SourceFile within the source_map of its original crate
     pub original_end_pos: syntax_pos::BytePos,
-    /// The imported SourceFile's representation within the local codemap
+    /// The imported SourceFile's representation within the local source_map
     pub translated_source_file: Lrc<syntax_pos::SourceFile>,
 }
 
@@ -64,7 +64,7 @@ pub struct CrateMetadata {
     pub cnum_map: CrateNumMap,
     pub cnum: CrateNum,
     pub dependencies: Lock<Vec<CrateNum>>,
-    pub codemap_import_info: RwLock<Vec<ImportedSourceFile>>,
+    pub source_map_import_info: RwLock<Vec<ImportedSourceFile>>,
 
     /// Used for decoding interpret::AllocIds in a cached & thread-safe manner.
     pub alloc_decoding_state: AllocDecodingState,