mv codemap() source_map()

Author: dsciarra

src/libproc_macro/lib.rs

@@ -1186,7 +1186,7 @@ pub mod __internal {
     use super::{TokenStream, LexError, Span};
 
     pub fn lookup_char_pos(pos: BytePos) -> Loc {
-        with_sess(|sess, _| sess.codemap().lookup_char_pos(pos))
+        with_sess(|sess, _| sess.source_map().lookup_char_pos(pos))
     }
 
     pub fn new_token_stream(item: P<ast::Item>) -> TokenStream {

src/librustc/hir/lowering.rs

@@ -3621,7 +3621,7 @@ impl<'a> LoweringContext<'a> {
                     let tail = block.expr.take().map_or_else(
                         || {
                             let LoweredNodeId { node_id, hir_id } = this.next_id();
-                            let span = this.sess.codemap().end_point(unstable_span);
+                            let span = this.sess.source_map().end_point(unstable_span);
                             hir::Expr {
                                 id: node_id,
                                 span,

src/librustc/hir/map/mod.rs

@@ -1202,7 +1202,7 @@ pub fn map_crate<'hir>(sess: &::session::Session,
         let cmdline_args = sess.opts.dep_tracking_hash();
         collector.finalize_and_compute_crate_hash(crate_disambiguator,
                                                   cstore,
-                                                  sess.codemap(),
+                                                  sess.source_map(),
                                                   cmdline_args)
     };
 

src/librustc/ich/hcx.rs

@@ -101,7 +101,7 @@ impl<'a> StableHashingContext<'a> {
             definitions,
             cstore,
             caching_codemap: None,
-            raw_codemap: sess.codemap(),
+            raw_codemap: sess.source_map(),
             hash_spans: hash_spans_initial,
             hash_bodies: true,
             node_id_hashing_mode: NodeIdHashingMode::HashDefPath,
@@ -169,7 +169,7 @@ impl<'a> StableHashingContext<'a> {
     }
 
     #[inline]
-    pub fn codemap(&mut self) -> &mut CachingCodemapView<'a> {
+    pub fn source_map(&mut self) -> &mut CachingCodemapView<'a> {
         match self.caching_codemap {
             Some(ref mut cm) => {
                 cm
@@ -340,7 +340,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for Span {
             return std_hash::Hash::hash(&TAG_INVALID_SPAN, hasher);
         }
 
-        let (file_lo, line_lo, col_lo) = match hcx.codemap()
+        let (file_lo, line_lo, col_lo) = match hcx.source_map()
                                                   .byte_pos_to_line_and_col(span.lo) {
             Some(pos) => pos,
             None => {

src/librustc/infer/error_reporting/mod.rs

@@ -189,7 +189,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self,
         region: ty::Region<'tcx>,
     ) -> (String, Option<Span>) {
-        let cm = self.sess.codemap();
+        let cm = self.sess.source_map();
 
         let scope = region.free_region_binding_scope(self);
         let node = self.hir.as_local_node_id(scope).unwrap_or(DUMMY_NODE_ID);
@@ -286,7 +286,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     }
 
     fn explain_span(self, heading: &str, span: Span) -> (String, Option<Span>) {
-        let lo = self.sess.codemap().lookup_char_pos_adj(span.lo());
+        let lo = self.sess.source_map().lookup_char_pos_adj(span.lo());
         (
             format!("the {} at {}:{}", heading, lo.line, lo.col.to_usize() + 1),
             Some(span),
@@ -502,14 +502,14 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
             ObligationCauseCode::MatchExpressionArm { arm_span, source } => match source {
                 hir::MatchSource::IfLetDesugar { .. } => {
                     let msg = "`if let` arm with an incompatible type";
-                    if self.tcx.sess.codemap().is_multiline(arm_span) {
+                    if self.tcx.sess.source_map().is_multiline(arm_span) {
                         err.span_note(arm_span, msg);
                     } else {
                         err.span_label(arm_span, msg);
                     }
                 },
                 hir::MatchSource::TryDesugar => { // Issue #51632
-                    if let Ok(try_snippet) = self.tcx.sess.codemap().span_to_snippet(arm_span) {
+                    if let Ok(try_snippet) = self.tcx.sess.source_map().span_to_snippet(arm_span) {
                         err.span_suggestion_with_applicability(
                             arm_span,
                             "try wrapping with a success variant",
@@ -520,7 +520,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                 },
                 _ => {
                     let msg = "match arm with an incompatible type";
-                    if self.tcx.sess.codemap().is_multiline(arm_span) {
+                    if self.tcx.sess.source_map().is_multiline(arm_span) {
                         err.span_note(arm_span, msg);
                     } else {
                         err.span_label(arm_span, msg);
@@ -1136,8 +1136,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                             let sp = if has_bounds {
                                 sp.to(self.tcx
                                     .sess
-                                    .codemap()
-                                    .next_point(self.tcx.sess.codemap().next_point(sp)))
+                                    .source_map()
+                                    .next_point(self.tcx.sess.source_map().next_point(sp)))
                             } else {
                                 sp
                             };

src/librustc/infer/error_reporting/nice_region_error/static_impl_trait.rs

@@ -60,7 +60,7 @@ impl<'a, 'gcx, 'tcx> NiceRegionError<'a, 'gcx, 'tcx> {
                             }) => name.to_string(),
                             _ => "'_".to_owned(),
                         };
-                        if let Ok(snippet) = self.tcx.sess.codemap().span_to_snippet(return_sp) {
+                        if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(return_sp) {
                             err.span_suggestion(
                                 return_sp,
                                 &format!(

src/librustc/lint/builtin.rs

@@ -420,7 +420,7 @@ impl BuiltinLintDiagnostics {
         match self {
             BuiltinLintDiagnostics::Normal => (),
             BuiltinLintDiagnostics::BareTraitObject(span, is_global) => {
-                let (sugg, app) = match sess.codemap().span_to_snippet(span) {
+                let (sugg, app) = match sess.source_map().span_to_snippet(span) {
                     Ok(ref s) if is_global => (format!("dyn ({})", s),
                                                Applicability::MachineApplicable),
                     Ok(s) => (format!("dyn {}", s), Applicability::MachineApplicable),
@@ -429,7 +429,7 @@ impl BuiltinLintDiagnostics {
                 db.span_suggestion_with_applicability(span, "use `dyn`", sugg, app);
             }
             BuiltinLintDiagnostics::AbsPathWithModule(span) => {
-                let (sugg, app) = match sess.codemap().span_to_snippet(span) {
+                let (sugg, app) = match sess.source_map().span_to_snippet(span) {
                     Ok(ref s) => {
                         // FIXME(Manishearth) ideally the emitting code
                         // can tell us whether or not this is global
@@ -462,7 +462,7 @@ impl BuiltinLintDiagnostics {
                     // When possible, prefer a suggestion that replaces the whole
                     // `Path<T>` expression with `Path<'_, T>`, rather than inserting `'_, `
                     // at a point (which makes for an ugly/confusing label)
-                    if let Ok(snippet) = sess.codemap().span_to_snippet(path_span) {
+                    if let Ok(snippet) = sess.source_map().span_to_snippet(path_span) {
                         // But our spans can get out of whack due to macros; if the place we think
                         // we want to insert `'_` isn't even within the path expression's span, we
                         // should bail out of making any suggestion rather than panicking on a

src/librustc/lint/mod.rs

@@ -754,7 +754,7 @@ pub fn in_external_macro(sess: &Session, span: Span) -> bool {
         None => return true,
     };
 
-    match sess.codemap().span_to_snippet(def_site) {
+    match sess.source_map().span_to_snippet(def_site) {
         Ok(code) => !code.starts_with("macro_rules"),
         // no snippet = external macro or compiler-builtin expansion
         Err(_) => true,

src/librustc/middle/dead.rs

@@ -551,7 +551,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {
                 hir::ItemKind::Struct(..) |
                 hir::ItemKind::Union(..) |
                 hir::ItemKind::Trait(..) |
-                hir::ItemKind::Impl(..) => self.tcx.sess.codemap().def_span(item.span),
+                hir::ItemKind::Impl(..) => self.tcx.sess.source_map().def_span(item.span),
                 _ => item.span,
             };
             let participle = match item.node {
@@ -612,7 +612,7 @@ impl<'a, 'tcx> Visitor<'tcx> for DeadVisitor<'a, 'tcx> {
             }
             hir::ImplItemKind::Method(_, body_id) => {
                 if !self.symbol_is_live(impl_item.id, None) {
-                    let span = self.tcx.sess.codemap().def_span(impl_item.span);
+                    let span = self.tcx.sess.source_map().def_span(impl_item.span);
                     self.warn_dead_code(impl_item.id, span, impl_item.ident.name, "method", "used");
                 }
                 self.visit_nested_body(body_id)

src/librustc/middle/liveness.rs

@@ -157,7 +157,7 @@ enum LiveNodeKind {
 }
 
 fn live_node_kind_to_string(lnk: LiveNodeKind, tcx: TyCtxt) -> String {
-    let cm = tcx.sess.codemap();
+    let cm = tcx.sess.source_map();
     match lnk {
         FreeVarNode(s) => {
             format!("Free var node [{}]", cm.span_to_string(s))