diff --git a/src/librustc/ich/caching_codemap_view.rs b/src/librustc/ich/caching_source_map_view.rs similarity index 100% rename from src/librustc/ich/caching_codemap_view.rs rename to src/librustc/ich/caching_source_map_view.rs diff --git a/src/librustc/ich/mod.rs b/src/librustc/ich/mod.rs index a23bab6226e..9751c560acd 100644 --- a/src/librustc/ich/mod.rs +++ b/src/librustc/ich/mod.rs @@ -11,10 +11,10 @@ //! ICH - Incremental Compilation Hash crate use rustc_data_structures::fingerprint::Fingerprint; -pub use self::caching_codemap_view::CachingSourceMapView; +pub use self::caching_source_map_view::CachingSourceMapView; pub use self::hcx::{StableHashingContextProvider, StableHashingContext, NodeIdHashingMode, hash_stable_trait_impls}; -mod caching_codemap_view; +mod caching_source_map_view; mod hcx; mod impls_cstore; diff --git a/src/librustc/ty/query/on_disk_cache.rs b/src/librustc/ty/query/on_disk_cache.rs index 636720bf3c4..d6f75318551 100644 --- a/src/librustc/ty/query/on_disk_cache.rs +++ b/src/librustc/ty/query/on_disk_cache.rs @@ -25,7 +25,7 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder, opaque, use session::{CrateDisambiguator, Session}; use std::mem; use syntax::ast::NodeId; -use syntax::source_map::{SourceMap, StableFilemapId}; +use syntax::source_map::{SourceMap, StableSourceFileId}; use syntax_pos::{BytePos, Span, DUMMY_SP, SourceFile}; use syntax_pos::hygiene::{Mark, SyntaxContext, ExpnInfo}; use ty; @@ -62,7 +62,7 @@ pub struct OnDiskCache<'sess> { cnum_map: Once>>, source_map: &'sess SourceMap, - file_index_to_stable_id: FxHashMap, + file_index_to_stable_id: FxHashMap, // These two fields caches that are populated lazily during decoding. file_index_to_file: Lock>>, @@ -82,7 +82,7 @@ pub struct OnDiskCache<'sess> { // This type is used only for (de-)serialization. #[derive(RustcEncodable, RustcDecodable)] struct Footer { - file_index_to_stable_id: FxHashMap, + file_index_to_stable_id: FxHashMap, prev_cnums: Vec<(u32, String, CrateDisambiguator)>, query_result_index: EncodedQueryResultIndex, diagnostics_index: EncodedQueryResultIndex, @@ -181,7 +181,7 @@ impl<'sess> OnDiskCache<'sess> { let index = SourceFileIndex(index as u32); let file_ptr: *const SourceFile = &**file as *const _; file_to_file_index.insert(file_ptr, index); - file_index_to_stable_id.insert(index, StableFilemapId::new(&file)); + file_index_to_stable_id.insert(index, StableSourceFileId::new(&file)); } (file_to_file_index, file_index_to_stable_id) @@ -473,7 +473,7 @@ struct CacheDecoder<'a, 'tcx: 'a, 'x> { cnum_map: &'x IndexVec>, synthetic_expansion_infos: &'x Lock>, file_index_to_file: &'x Lock>>, - file_index_to_stable_id: &'x FxHashMap, + file_index_to_stable_id: &'x FxHashMap, alloc_decoding_session: AllocDecodingSession<'x>, } diff --git a/src/librustc_errors/emitter.rs b/src/librustc_errors/emitter.rs index 5f275b70038..720e8def5ab 100644 --- a/src/librustc_errors/emitter.rs +++ b/src/librustc_errors/emitter.rs @@ -120,7 +120,7 @@ impl ColorConfig { pub struct EmitterWriter { dst: Destination, - cm: Option>, + sm: Option>, short_message: bool, teach: bool, ui_testing: bool, @@ -134,14 +134,14 @@ struct FileWithAnnotatedLines { impl EmitterWriter { pub fn stderr(color_config: ColorConfig, - code_map: Option>, + source_map: Option>, short_message: bool, teach: bool) -> EmitterWriter { let dst = Destination::from_stderr(color_config); EmitterWriter { dst, - cm: code_map, + sm: source_map, short_message, teach, ui_testing: false, @@ -149,13 +149,13 @@ impl EmitterWriter { } pub fn new(dst: Box, - code_map: Option>, + source_map: Option>, short_message: bool, teach: bool) -> EmitterWriter { EmitterWriter { dst: Raw(dst), - cm: code_map, + sm: source_map, short_message, teach, ui_testing: false, @@ -214,14 +214,14 @@ impl EmitterWriter { let mut output = vec![]; let mut multiline_annotations = vec![]; - if let Some(ref cm) = self.cm { + if let Some(ref sm) = self.sm { for span_label in msp.span_labels() { if span_label.span.is_dummy() { continue; } - let lo = cm.lookup_char_pos(span_label.span.lo()); - let mut hi = cm.lookup_char_pos(span_label.span.hi()); + let lo = sm.lookup_char_pos(span_label.span.lo()); + let mut hi = sm.lookup_char_pos(span_label.span.hi()); // Watch out for "empty spans". If we get a span like 6..6, we // want to just display a `^` at 6, so convert that to @@ -724,10 +724,10 @@ impl EmitterWriter { fn get_multispan_max_line_num(&mut self, msp: &MultiSpan) -> usize { let mut max = 0; - if let Some(ref cm) = self.cm { + if let Some(ref sm) = self.sm { for primary_span in msp.primary_spans() { if !primary_span.is_dummy() { - let hi = cm.lookup_char_pos(primary_span.hi()); + let hi = sm.lookup_char_pos(primary_span.hi()); if hi.line > max { max = hi.line; } @@ -736,7 +736,7 @@ impl EmitterWriter { if !self.short_message { for span_label in msp.span_labels() { if !span_label.span.is_dummy() { - let hi = cm.lookup_char_pos(span_label.span.hi()); + let hi = sm.lookup_char_pos(span_label.span.hi()); if hi.line > max { max = hi.line; } @@ -768,7 +768,7 @@ impl EmitterWriter { always_backtrace: bool) -> bool { let mut spans_updated = false; - if let Some(ref cm) = self.cm { + if let Some(ref sm) = self.sm { let mut before_after: Vec<(Span, Span)> = vec![]; let mut new_labels: Vec<(Span, String)> = vec![]; @@ -777,7 +777,7 @@ impl EmitterWriter { if sp.is_dummy() { continue; } - let call_sp = cm.call_span_if_macro(*sp); + let call_sp = sm.call_span_if_macro(*sp); if call_sp != *sp && !always_backtrace { before_after.push((*sp, call_sp)); } @@ -802,7 +802,7 @@ impl EmitterWriter { }))); } // Check to make sure we're not in any <*macros> - if !cm.span_to_filename(def_site).is_macros() && + if !sm.span_to_filename(def_site).is_macros() && !trace.macro_decl_name.starts_with("desugaring of ") && !trace.macro_decl_name.starts_with("#[") || always_backtrace { @@ -829,7 +829,7 @@ impl EmitterWriter { if sp_label.span.is_dummy() { continue; } - if cm.span_to_filename(sp_label.span.clone()).is_macros() && + if sm.span_to_filename(sp_label.span.clone()).is_macros() && !always_backtrace { let v = sp_label.span.macro_backtrace(); @@ -1000,10 +1000,10 @@ impl EmitterWriter { let mut annotated_files = self.preprocess_annotations(msp); // Make sure our primary file comes first - let (primary_lo, cm) = if let (Some(cm), Some(ref primary_span)) = - (self.cm.as_ref(), msp.primary_span().as_ref()) { + let (primary_lo, sm) = if let (Some(sm), Some(ref primary_span)) = + (self.sm.as_ref(), msp.primary_span().as_ref()) { if !primary_span.is_dummy() { - (cm.lookup_char_pos(primary_span.lo()), cm) + (sm.lookup_char_pos(primary_span.lo()), sm) } else { emit_to_destination(&buffer.render(), level, &mut self.dst, self.short_message)?; return Ok(()); @@ -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_source_file_source_present(annotated_file.file.clone()) { + if !sm.ensure_source_file_source_present(annotated_file.file.clone()) { continue; } @@ -1038,7 +1038,7 @@ impl EmitterWriter { buffer.append(buffer_msg_line_offset, &format!("{}:{}:{}", loc.file.name, - cm.doctest_offset_line(loc.line), + sm.doctest_offset_line(loc.line), loc.col.0 + 1), Style::LineAndColumn); for _ in 0..max_line_num_len { @@ -1048,7 +1048,7 @@ impl EmitterWriter { buffer.prepend(0, &format!("{}:{}:{}: ", loc.file.name, - cm.doctest_offset_line(loc.line), + sm.doctest_offset_line(loc.line), loc.col.0 + 1), Style::LineAndColumn); } @@ -1069,7 +1069,7 @@ impl EmitterWriter { }; format!("{}:{}{}", annotated_file.file.name, - cm.doctest_offset_line(first_line.line_index), + sm.doctest_offset_line(first_line.line_index), col) } else { annotated_file.file.name.to_string() @@ -1194,7 +1194,7 @@ impl EmitterWriter { level: &Level, max_line_num_len: usize) -> io::Result<()> { - if let Some(ref cm) = self.cm { + if let Some(ref sm) = self.sm { let mut buffer = StyledBuffer::new(); // Render the suggestion message @@ -1210,7 +1210,7 @@ impl EmitterWriter { Some(Style::HeaderMsg)); // Render the replacements for each suggestion - let suggestions = suggestion.splice_lines(&**cm); + let suggestions = suggestion.splice_lines(&**sm); let mut row_num = 2; for &(ref complete, ref parts) in suggestions.iter().take(MAX_SUGGESTIONS) { @@ -1221,11 +1221,11 @@ impl EmitterWriter { && parts[0].snippet.trim() == complete.trim()) && complete.lines().count() == 1; - let lines = cm.span_to_lines(parts[0].span).unwrap(); + let lines = sm.span_to_lines(parts[0].span).unwrap(); assert!(!lines.lines.is_empty()); - let line_start = cm.lookup_char_pos(parts[0].span.lo()).line; + let line_start = sm.lookup_char_pos(parts[0].span.lo()).line; draw_col_separator_no_space(&mut buffer, 1, max_line_num_len + 1); let mut line_pos = 0; let mut lines = complete.lines(); @@ -1250,8 +1250,8 @@ impl EmitterWriter { if show_underline { draw_col_separator(&mut buffer, row_num, max_line_num_len + 1); for part in parts { - let span_start_pos = cm.lookup_char_pos(part.span.lo()).col_display; - let span_end_pos = cm.lookup_char_pos(part.span.hi()).col_display; + let span_start_pos = sm.lookup_char_pos(part.span.lo()).col_display; + let span_end_pos = sm.lookup_char_pos(part.span.hi()).col_display; // Do not underline the leading... let start = part.snippet.len() diff --git a/src/librustc_errors/lib.rs b/src/librustc_errors/lib.rs index 9bd95e8262f..0fb77a7a3ab 100644 --- a/src/librustc_errors/lib.rs +++ b/src/librustc_errors/lib.rs @@ -129,7 +129,7 @@ pub trait SourceMapper { fn span_to_filename(&self, sp: Span) -> FileName; fn merge_spans(&self, sp_lhs: Span, sp_rhs: Span) -> Option; fn call_span_if_macro(&self, sp: Span) -> Span; - fn ensure_source_file_source_present(&self, file_map: Lrc) -> bool; + fn ensure_source_file_source_present(&self, source_file: Lrc) -> bool; fn doctest_offset_line(&self, line: usize) -> usize; } diff --git a/src/libsyntax/json.rs b/src/libsyntax/json.rs index b0cf29e9f63..a32682967c7 100644 --- a/src/libsyntax/json.rs +++ b/src/libsyntax/json.rs @@ -36,19 +36,19 @@ use rustc_serialize::json::{as_json, as_pretty_json}; pub struct JsonEmitter { dst: Box, registry: Option, - cm: Lrc, + sm: Lrc, pretty: bool, ui_testing: bool, } impl JsonEmitter { pub fn stderr(registry: Option, - code_map: Lrc, + source_map: Lrc, pretty: bool) -> JsonEmitter { JsonEmitter { dst: Box::new(io::stderr()), registry, - cm: code_map, + sm: source_map, pretty, ui_testing: false, } @@ -62,12 +62,12 @@ impl JsonEmitter { pub fn new(dst: Box, registry: Option, - code_map: Lrc, + source_map: Lrc, pretty: bool) -> JsonEmitter { JsonEmitter { dst, registry, - cm: code_map, + sm: source_map, pretty, ui_testing: false, } @@ -199,7 +199,7 @@ impl Diagnostic { } let buf = BufWriter::default(); let output = buf.clone(); - EmitterWriter::new(Box::new(buf), Some(je.cm.clone()), false, false) + EmitterWriter::new(Box::new(buf), Some(je.sm.clone()), false, false) .ui_testing(je.ui_testing).emit(db); let output = Arc::try_unwrap(output.0).unwrap().into_inner().unwrap(); let output = String::from_utf8(output).unwrap(); @@ -269,8 +269,8 @@ impl DiagnosticSpan { mut backtrace: vec::IntoIter, je: &JsonEmitter) -> DiagnosticSpan { - let start = je.cm.lookup_char_pos(span.lo()); - let end = je.cm.lookup_char_pos(span.hi()); + let start = je.sm.lookup_char_pos(span.lo()); + let end = je.sm.lookup_char_pos(span.hi()); let backtrace_step = backtrace.next().map(|bt| { let call_site = Self::from_span_full(bt.call_site, @@ -356,7 +356,7 @@ impl DiagnosticSpanLine { /// of `span` gets a DiagnosticSpanLine, with the highlight indicating the /// `span` within the line. fn from_span(span: Span, je: &JsonEmitter) -> Vec { - je.cm.span_to_lines(span) + je.sm.span_to_lines(span) .map(|lines| { let fm = &*lines.file; lines.lines diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index a814c88ee78..465ce73e01d 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -256,11 +256,11 @@ impl<'a> StringReader<'a> { let end = sess.source_map().lookup_byte_offset(span.hi()); // Make the range zero-length if the span is invalid. - if span.lo() > span.hi() || begin.fm.start_pos != end.fm.start_pos { + if span.lo() > span.hi() || begin.sf.start_pos != end.sf.start_pos { span = span.shrink_to_lo(); } - let mut sr = StringReader::new_raw_internal(sess, begin.fm, None); + let mut sr = StringReader::new_raw_internal(sess, begin.sf, None); // Seek the lexer to the right byte range. sr.next_pos = span.lo(); @@ -640,9 +640,9 @@ impl<'a> StringReader<'a> { // I guess this is the only way to figure out if // we're at the beginning of the file... - let cmap = SourceMap::new(FilePathMapping::empty()); - cmap.files.borrow_mut().file_maps.push(self.source_file.clone()); - let loc = cmap.lookup_char_pos_adj(self.pos); + let smap = SourceMap::new(FilePathMapping::empty()); + smap.files.borrow_mut().source_files.push(self.source_file.clone()); + let loc = smap.lookup_char_pos_adj(self.pos); debug!("Skipping a shebang"); if loc.line == 1 && loc.col == CharPos(0) { // FIXME: Add shebang "token", return it @@ -1855,9 +1855,9 @@ mod tests { use rustc_data_structures::fx::FxHashSet; use rustc_data_structures::sync::Lock; use with_globals; - fn mk_sess(cm: Lrc) -> ParseSess { + fn mk_sess(sm: Lrc) -> ParseSess { let emitter = errors::emitter::EmitterWriter::new(Box::new(io::sink()), - Some(cm.clone()), + Some(sm.clone()), false, false); ParseSess { @@ -1865,7 +1865,7 @@ mod tests { unstable_features: UnstableFeatures::from_environment(), config: CrateConfig::default(), included_mod_stack: Lock::new(Vec::new()), - code_map: cm, + source_map: sm, missing_fragment_specifiers: Lock::new(FxHashSet::default()), raw_identifier_spans: Lock::new(Vec::new()), registered_diagnostics: Lock::new(ErrorMap::new()), @@ -1875,20 +1875,20 @@ mod tests { } // open a string reader for the given string - fn setup<'a>(cm: &SourceMap, + fn setup<'a>(sm: &SourceMap, sess: &'a ParseSess, teststr: String) -> StringReader<'a> { - let fm = cm.new_source_file(PathBuf::from("zebra.rs").into(), teststr); - StringReader::new(sess, fm, None) + let sf = sm.new_source_file(PathBuf::from("zebra.rs").into(), teststr); + StringReader::new(sess, sf, None) } #[test] fn t1() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - let mut string_reader = setup(&cm, + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + let mut string_reader = setup(&sm, &sh, "/* my source file */ fn main() { println!(\"zebra\"); }\n" .to_string()); @@ -1934,9 +1934,9 @@ mod tests { #[test] fn doublecolonparsing() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - check_tokenization(setup(&cm, &sh, "a b".to_string()), + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + check_tokenization(setup(&sm, &sh, "a b".to_string()), vec![mk_ident("a"), token::Whitespace, mk_ident("b")]); }) } @@ -1944,9 +1944,9 @@ mod tests { #[test] fn dcparsing_2() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - check_tokenization(setup(&cm, &sh, "a::b".to_string()), + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + check_tokenization(setup(&sm, &sh, "a::b".to_string()), vec![mk_ident("a"), token::ModSep, mk_ident("b")]); }) } @@ -1954,9 +1954,9 @@ mod tests { #[test] fn dcparsing_3() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - check_tokenization(setup(&cm, &sh, "a ::b".to_string()), + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + check_tokenization(setup(&sm, &sh, "a ::b".to_string()), vec![mk_ident("a"), token::Whitespace, token::ModSep, mk_ident("b")]); }) } @@ -1964,9 +1964,9 @@ mod tests { #[test] fn dcparsing_4() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - check_tokenization(setup(&cm, &sh, "a:: b".to_string()), + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + check_tokenization(setup(&sm, &sh, "a:: b".to_string()), vec![mk_ident("a"), token::ModSep, token::Whitespace, mk_ident("b")]); }) } @@ -1974,9 +1974,9 @@ mod tests { #[test] fn character_a() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - assert_eq!(setup(&cm, &sh, "'a'".to_string()).next_token().tok, + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + assert_eq!(setup(&sm, &sh, "'a'".to_string()).next_token().tok, token::Literal(token::Char(Symbol::intern("a")), None)); }) } @@ -1984,9 +1984,9 @@ mod tests { #[test] fn character_space() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - assert_eq!(setup(&cm, &sh, "' '".to_string()).next_token().tok, + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + assert_eq!(setup(&sm, &sh, "' '".to_string()).next_token().tok, token::Literal(token::Char(Symbol::intern(" ")), None)); }) } @@ -1994,9 +1994,9 @@ mod tests { #[test] fn character_escaped() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - assert_eq!(setup(&cm, &sh, "'\\n'".to_string()).next_token().tok, + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + assert_eq!(setup(&sm, &sh, "'\\n'".to_string()).next_token().tok, token::Literal(token::Char(Symbol::intern("\\n")), None)); }) } @@ -2004,9 +2004,9 @@ mod tests { #[test] fn lifetime_name() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - assert_eq!(setup(&cm, &sh, "'abc".to_string()).next_token().tok, + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + assert_eq!(setup(&sm, &sh, "'abc".to_string()).next_token().tok, token::Lifetime(Ident::from_str("'abc"))); }) } @@ -2014,9 +2014,9 @@ mod tests { #[test] fn raw_string() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - assert_eq!(setup(&cm, &sh, "r###\"\"#a\\b\x00c\"\"###".to_string()) + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + assert_eq!(setup(&sm, &sh, "r###\"\"#a\\b\x00c\"\"###".to_string()) .next_token() .tok, token::Literal(token::StrRaw(Symbol::intern("\"#a\\b\x00c\""), 3), None)); @@ -2026,15 +2026,15 @@ mod tests { #[test] fn literal_suffixes() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); macro_rules! test { ($input: expr, $tok_type: ident, $tok_contents: expr) => {{ - assert_eq!(setup(&cm, &sh, format!("{}suffix", $input)).next_token().tok, + assert_eq!(setup(&sm, &sh, format!("{}suffix", $input)).next_token().tok, token::Literal(token::$tok_type(Symbol::intern($tok_contents)), Some(Symbol::intern("suffix")))); // with a whitespace separator: - assert_eq!(setup(&cm, &sh, format!("{} suffix", $input)).next_token().tok, + assert_eq!(setup(&sm, &sh, format!("{} suffix", $input)).next_token().tok, token::Literal(token::$tok_type(Symbol::intern($tok_contents)), None)); }} @@ -2050,13 +2050,13 @@ mod tests { test!("1.0", Float, "1.0"); test!("1.0e10", Float, "1.0e10"); - assert_eq!(setup(&cm, &sh, "2us".to_string()).next_token().tok, + assert_eq!(setup(&sm, &sh, "2us".to_string()).next_token().tok, token::Literal(token::Integer(Symbol::intern("2")), Some(Symbol::intern("us")))); - assert_eq!(setup(&cm, &sh, "r###\"raw\"###suffix".to_string()).next_token().tok, + assert_eq!(setup(&sm, &sh, "r###\"raw\"###suffix".to_string()).next_token().tok, token::Literal(token::StrRaw(Symbol::intern("raw"), 3), Some(Symbol::intern("suffix")))); - assert_eq!(setup(&cm, &sh, "br###\"raw\"###suffix".to_string()).next_token().tok, + assert_eq!(setup(&sm, &sh, "br###\"raw\"###suffix".to_string()).next_token().tok, token::Literal(token::ByteStrRaw(Symbol::intern("raw"), 3), Some(Symbol::intern("suffix")))); }) @@ -2072,9 +2072,9 @@ mod tests { #[test] fn nested_block_comments() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - let mut lexer = setup(&cm, &sh, "/* /* */ */'a'".to_string()); + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + let mut lexer = setup(&sm, &sh, "/* /* */ */'a'".to_string()); match lexer.next_token().tok { token::Comment => {} _ => panic!("expected a comment!"), @@ -2087,9 +2087,9 @@ mod tests { #[test] fn crlf_comments() { with_globals(|| { - let cm = Lrc::new(SourceMap::new(FilePathMapping::empty())); - let sh = mk_sess(cm.clone()); - let mut lexer = setup(&cm, &sh, "// test\r\n/// test\r\n".to_string()); + let sm = Lrc::new(SourceMap::new(FilePathMapping::empty())); + let sh = mk_sess(sm.clone()); + let mut lexer = setup(&sm, &sh, "// test\r\n/// test\r\n".to_string()); let comment = lexer.next_token(); assert_eq!(comment.tok, token::Comment); assert_eq!((comment.sp.lo(), comment.sp.hi()), (BytePos(0), BytePos(7))); diff --git a/src/libsyntax/parse/mod.rs b/src/libsyntax/parse/mod.rs index 77a2ae6acf0..ce32520b8e7 100644 --- a/src/libsyntax/parse/mod.rs +++ b/src/libsyntax/parse/mod.rs @@ -57,7 +57,7 @@ pub struct ParseSess { pub non_modrs_mods: Lock>, /// Used to determine and report recursive mod inclusions included_mod_stack: Lock>, - code_map: Lrc, + source_map: Lrc, pub buffered_lints: Lock>, } @@ -71,7 +71,7 @@ impl ParseSess { ParseSess::with_span_handler(handler, cm) } - pub fn with_span_handler(handler: Handler, code_map: Lrc) -> ParseSess { + pub fn with_span_handler(handler: Handler, source_map: Lrc) -> ParseSess { ParseSess { span_diagnostic: handler, unstable_features: UnstableFeatures::from_environment(), @@ -80,14 +80,14 @@ impl ParseSess { raw_identifier_spans: Lock::new(Vec::new()), registered_diagnostics: Lock::new(ErrorMap::new()), included_mod_stack: Lock::new(vec![]), - code_map, + source_map, non_modrs_mods: Lock::new(vec![]), buffered_lints: Lock::new(vec![]), } } pub fn source_map(&self) -> &SourceMap { - &self.code_map + &self.source_map } pub fn buffer_lint>(&self, diff --git a/src/libsyntax/source_map.rs b/src/libsyntax/source_map.rs index 17586a442da..e8cacc3b5af 100644 --- a/src/libsyntax/source_map.rs +++ b/src/libsyntax/source_map.rs @@ -106,17 +106,17 @@ impl FileLoader for RealFileLoader { // subsequent compilation sessions (which is something we need to do during // incremental compilation). #[derive(Copy, Clone, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable, Debug)] -pub struct StableFilemapId(u128); +pub struct StableSourceFileId(u128); -impl StableFilemapId { - pub fn new(source_file: &SourceFile) -> StableFilemapId { +impl StableSourceFileId { + pub fn new(source_file: &SourceFile) -> StableSourceFileId { let mut hasher = StableHasher::new(); source_file.name.hash(&mut hasher); source_file.name_was_remapped.hash(&mut hasher); source_file.unmapped_path.hash(&mut hasher); - StableFilemapId(hasher.finish()) + StableSourceFileId(hasher.finish()) } } @@ -126,8 +126,8 @@ impl StableFilemapId { #[derive(Default)] pub(super) struct SourceMapFiles { - pub(super) file_maps: Vec>, - stable_id_to_source_file: FxHashMap> + pub(super) source_files: Vec>, + stable_id_to_source_file: FxHashMap> } pub struct SourceMap { @@ -190,15 +190,16 @@ impl SourceMap { } pub fn files(&self) -> MappedLockGuard>> { - LockGuard::map(self.files.borrow(), |files| &mut files.file_maps) + LockGuard::map(self.files.borrow(), |files| &mut files.source_files) } - pub fn source_file_by_stable_id(&self, stable_id: StableFilemapId) -> Option> { - self.files.borrow().stable_id_to_source_file.get(&stable_id).map(|fm| fm.clone()) + pub fn source_file_by_stable_id(&self, stable_id: StableSourceFileId) -> + Option> { + self.files.borrow().stable_id_to_source_file.get(&stable_id).map(|sf| sf.clone()) } fn next_start_pos(&self) -> usize { - match self.files.borrow().file_maps.last() { + match self.files.borrow().source_files.last() { None => 0, // Add one so there is some space between files. This lets us distinguish // positions in the source_map, even in the presence of zero-length files. @@ -235,8 +236,8 @@ impl SourceMap { let mut files = self.files.borrow_mut(); - files.file_maps.push(source_file.clone()); - files.stable_id_to_source_file.insert(StableFilemapId::new(&source_file), + files.source_files.push(source_file.clone()); + files.stable_id_to_source_file.insert(StableSourceFileId::new(&source_file), source_file.clone()); source_file @@ -293,8 +294,8 @@ impl SourceMap { let mut files = self.files.borrow_mut(); - files.file_maps.push(source_file.clone()); - files.stable_id_to_source_file.insert(StableFilemapId::new(&source_file), + files.source_files.push(source_file.clone()); + files.stable_id_to_source_file.insert(StableSourceFileId::new(&source_file), source_file.clone()); source_file @@ -324,7 +325,7 @@ impl SourceMap { pub fn lookup_char_pos(&self, pos: BytePos) -> Loc { let chpos = self.bytepos_to_file_charpos(pos); match self.lookup_line(pos) { - Ok(SourceFileAndLine { fm: f, line: a }) => { + Ok(SourceFileAndLine { sf: f, line: a }) => { let line = a + 1; // Line numbers start at 1 let linebpos = f.lines[a]; let linechpos = self.bytepos_to_file_charpos(linebpos); @@ -387,10 +388,10 @@ impl SourceMap { pub fn lookup_line(&self, pos: BytePos) -> Result> { let idx = self.lookup_source_file_idx(pos); - let f = (*self.files.borrow().file_maps)[idx].clone(); + let f = (*self.files.borrow().source_files)[idx].clone(); match f.lookup_line(pos) { - Some(line) => Ok(SourceFileAndLine { fm: f, line: line }), + Some(line) => Ok(SourceFileAndLine { sf: f, line: line }), None => Err(f) } } @@ -441,7 +442,7 @@ impl SourceMap { } pub fn span_to_string(&self, sp: Span) -> String { - if self.files.borrow().file_maps.is_empty() && sp.is_dummy() { + if self.files.borrow().source_files.is_empty() && sp.is_dummy() { return "no-location".to_string(); } @@ -531,38 +532,38 @@ impl SourceMap { let local_begin = self.lookup_byte_offset(sp.lo()); let local_end = self.lookup_byte_offset(sp.hi()); - if local_begin.fm.start_pos != local_end.fm.start_pos { + if local_begin.sf.start_pos != local_end.sf.start_pos { return Err(SpanSnippetError::DistinctSources(DistinctSources { - begin: (local_begin.fm.name.clone(), - local_begin.fm.start_pos), - end: (local_end.fm.name.clone(), - local_end.fm.start_pos) + begin: (local_begin.sf.name.clone(), + local_begin.sf.start_pos), + end: (local_end.sf.name.clone(), + local_end.sf.start_pos) })); } else { - self.ensure_source_file_source_present(local_begin.fm.clone()); + self.ensure_source_file_source_present(local_begin.sf.clone()); let start_index = local_begin.pos.to_usize(); let end_index = local_end.pos.to_usize(); - let source_len = (local_begin.fm.end_pos - - local_begin.fm.start_pos).to_usize(); + let source_len = (local_begin.sf.end_pos - + local_begin.sf.start_pos).to_usize(); if start_index > end_index || end_index > source_len { - return Err(SpanSnippetError::MalformedForCodemap( - MalformedCodemapPositions { - name: local_begin.fm.name.clone(), + return Err(SpanSnippetError::MalformedForSourcemap( + MalformedSourceMapPositions { + name: local_begin.sf.name.clone(), source_len, begin_pos: local_begin.pos, end_pos: local_end.pos, })); } - if let Some(ref src) = local_begin.fm.src { + if let Some(ref src) = local_begin.sf.src { return Ok(extract_source(src, start_index, end_index)); - } else if let Some(src) = local_begin.fm.external_src.borrow().get_source() { + } else if let Some(src) = local_begin.sf.external_src.borrow().get_source() { return Ok(extract_source(src, start_index, end_index)); } else { return Err(SpanSnippetError::SourceNotAvailable { - filename: local_begin.fm.name.clone() + filename: local_begin.sf.name.clone() }); } } @@ -757,7 +758,7 @@ impl SourceMap { return 1; } - let source_len = (local_begin.fm.end_pos - local_begin.fm.start_pos).to_usize(); + let source_len = (local_begin.sf.end_pos - local_begin.sf.start_pos).to_usize(); debug!("find_width_of_character_at_span: source_len=`{:?}`", source_len); // Ensure indexes are also not malformed. if start_index > end_index || end_index > source_len { @@ -765,11 +766,11 @@ impl SourceMap { return 1; } - let src = local_begin.fm.external_src.borrow(); + let src = local_begin.sf.external_src.borrow(); // We need to extend the snippet to the end of the src rather than to end_index so when // searching forwards for boundaries we've got somewhere to search. - let snippet = if let Some(ref src) = local_begin.fm.src { + let snippet = if let Some(ref src) = local_begin.sf.src { let len = src.len(); (&src[start_index..len]) } else if let Some(src) = src.get_source() { @@ -806,9 +807,9 @@ impl SourceMap { } pub fn get_source_file(&self, filename: &FileName) -> Option> { - for fm in self.files.borrow().file_maps.iter() { - if *filename == fm.name { - return Some(fm.clone()); + for sf in self.files.borrow().source_files.iter() { + if *filename == sf.name { + return Some(sf.clone()); } } None @@ -817,15 +818,15 @@ impl SourceMap { /// For a global BytePos compute the local offset within the containing SourceFile pub fn lookup_byte_offset(&self, bpos: BytePos) -> SourceFileAndBytePos { let idx = self.lookup_source_file_idx(bpos); - let fm = (*self.files.borrow().file_maps)[idx].clone(); - let offset = bpos - fm.start_pos; - SourceFileAndBytePos {fm: fm, pos: offset} + let sf = (*self.files.borrow().source_files)[idx].clone(); + let offset = bpos - sf.start_pos; + SourceFileAndBytePos {sf: sf, pos: offset} } /// Converts an absolute BytePos to a CharPos relative to the source_file. pub fn bytepos_to_file_charpos(&self, bpos: BytePos) -> CharPos { let idx = self.lookup_source_file_idx(bpos); - let map = &(*self.files.borrow().file_maps)[idx]; + let map = &(*self.files.borrow().source_files)[idx]; // The number of extra bytes due to multibyte chars in the SourceFile let mut total_extra_bytes = 0; @@ -851,7 +852,7 @@ impl SourceMap { // Return the index of the source_file (in self.files) which contains pos. pub fn lookup_source_file_idx(&self, pos: BytePos) -> usize { let files = self.files.borrow(); - let files = &files.file_maps; + let files = &files.source_files; let count = files.len(); // Binary search for the source_file. @@ -974,9 +975,9 @@ impl SourceMapper for SourceMap { } sp } - fn ensure_source_file_source_present(&self, file_map: Lrc) -> bool { - file_map.add_external_src( - || match file_map.name { + fn ensure_source_file_source_present(&self, source_file: Lrc) -> bool { + source_file.add_external_src( + || match source_file.name { FileName::Real(ref name) => self.file_loader.read_file(name).ok(), _ => None, } @@ -1031,97 +1032,97 @@ mod tests { use super::*; use rustc_data_structures::sync::Lrc; - fn init_code_map() -> SourceMap { - let cm = SourceMap::new(FilePathMapping::empty()); - cm.new_source_file(PathBuf::from("blork.rs").into(), + fn init_source_map() -> SourceMap { + let sm = SourceMap::new(FilePathMapping::empty()); + sm.new_source_file(PathBuf::from("blork.rs").into(), "first line.\nsecond line".to_string()); - cm.new_source_file(PathBuf::from("empty.rs").into(), + sm.new_source_file(PathBuf::from("empty.rs").into(), String::new()); - cm.new_source_file(PathBuf::from("blork2.rs").into(), + sm.new_source_file(PathBuf::from("blork2.rs").into(), "first line.\nsecond line".to_string()); - cm + sm } #[test] fn t3() { // Test lookup_byte_offset - let cm = init_code_map(); + let sm = init_source_map(); - let fmabp1 = cm.lookup_byte_offset(BytePos(23)); - assert_eq!(fmabp1.fm.name, PathBuf::from("blork.rs").into()); - assert_eq!(fmabp1.pos, BytePos(23)); + let srcfbp1 = sm.lookup_byte_offset(BytePos(23)); + assert_eq!(srcfbp1.sf.name, PathBuf::from("blork.rs").into()); + assert_eq!(srcfbp1.pos, BytePos(23)); - let fmabp1 = cm.lookup_byte_offset(BytePos(24)); - assert_eq!(fmabp1.fm.name, PathBuf::from("empty.rs").into()); - assert_eq!(fmabp1.pos, BytePos(0)); + let srcfbp1 = sm.lookup_byte_offset(BytePos(24)); + assert_eq!(srcfbp1.sf.name, PathBuf::from("empty.rs").into()); + assert_eq!(srcfbp1.pos, BytePos(0)); - let fmabp2 = cm.lookup_byte_offset(BytePos(25)); - assert_eq!(fmabp2.fm.name, PathBuf::from("blork2.rs").into()); - assert_eq!(fmabp2.pos, BytePos(0)); + let srcfbp2 = sm.lookup_byte_offset(BytePos(25)); + assert_eq!(srcfbp2.sf.name, PathBuf::from("blork2.rs").into()); + assert_eq!(srcfbp2.pos, BytePos(0)); } #[test] fn t4() { // Test bytepos_to_file_charpos - let cm = init_code_map(); + let sm = init_source_map(); - let cp1 = cm.bytepos_to_file_charpos(BytePos(22)); + let cp1 = sm.bytepos_to_file_charpos(BytePos(22)); assert_eq!(cp1, CharPos(22)); - let cp2 = cm.bytepos_to_file_charpos(BytePos(25)); + let cp2 = sm.bytepos_to_file_charpos(BytePos(25)); assert_eq!(cp2, CharPos(0)); } #[test] fn t5() { // Test zero-length source_files. - let cm = init_code_map(); + let sm = init_source_map(); - let loc1 = cm.lookup_char_pos(BytePos(22)); + let loc1 = sm.lookup_char_pos(BytePos(22)); assert_eq!(loc1.file.name, PathBuf::from("blork.rs").into()); assert_eq!(loc1.line, 2); assert_eq!(loc1.col, CharPos(10)); - let loc2 = cm.lookup_char_pos(BytePos(25)); + let loc2 = sm.lookup_char_pos(BytePos(25)); assert_eq!(loc2.file.name, PathBuf::from("blork2.rs").into()); assert_eq!(loc2.line, 1); assert_eq!(loc2.col, CharPos(0)); } - fn init_code_map_mbc() -> SourceMap { - let cm = SourceMap::new(FilePathMapping::empty()); + fn init_source_map_mbc() -> SourceMap { + let sm = SourceMap::new(FilePathMapping::empty()); // € is a three byte utf8 char. - cm.new_source_file(PathBuf::from("blork.rs").into(), + sm.new_source_file(PathBuf::from("blork.rs").into(), "fir€st €€€€ line.\nsecond line".to_string()); - cm.new_source_file(PathBuf::from("blork2.rs").into(), + sm.new_source_file(PathBuf::from("blork2.rs").into(), "first line€€.\n€ second line".to_string()); - cm + sm } #[test] fn t6() { // Test bytepos_to_file_charpos in the presence of multi-byte chars - let cm = init_code_map_mbc(); + let sm = init_source_map_mbc(); - let cp1 = cm.bytepos_to_file_charpos(BytePos(3)); + let cp1 = sm.bytepos_to_file_charpos(BytePos(3)); assert_eq!(cp1, CharPos(3)); - let cp2 = cm.bytepos_to_file_charpos(BytePos(6)); + let cp2 = sm.bytepos_to_file_charpos(BytePos(6)); assert_eq!(cp2, CharPos(4)); - let cp3 = cm.bytepos_to_file_charpos(BytePos(56)); + let cp3 = sm.bytepos_to_file_charpos(BytePos(56)); assert_eq!(cp3, CharPos(12)); - let cp4 = cm.bytepos_to_file_charpos(BytePos(61)); + let cp4 = sm.bytepos_to_file_charpos(BytePos(61)); assert_eq!(cp4, CharPos(15)); } #[test] fn t7() { // Test span_to_lines for a span ending at the end of source_file - let cm = init_code_map(); + let sm = init_source_map(); let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION); - let file_lines = cm.span_to_lines(span).unwrap(); + let file_lines = sm.span_to_lines(span).unwrap(); assert_eq!(file_lines.file.name, PathBuf::from("blork.rs").into()); assert_eq!(file_lines.lines.len(), 1); @@ -1143,17 +1144,17 @@ mod tests { /// lines in the middle of a file. #[test] fn span_to_snippet_and_lines_spanning_multiple_lines() { - let cm = SourceMap::new(FilePathMapping::empty()); + let sm = SourceMap::new(FilePathMapping::empty()); let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n"; let selection = " \n ~~\n~~~\n~~~~~ \n \n"; - cm.new_source_file(Path::new("blork.rs").to_owned().into(), inputtext.to_string()); + sm.new_source_file(Path::new("blork.rs").to_owned().into(), inputtext.to_string()); let span = span_from_selection(inputtext, selection); // check that we are extracting the text we thought we were extracting - assert_eq!(&cm.span_to_snippet(span).unwrap(), "BB\nCCC\nDDDDD"); + assert_eq!(&sm.span_to_snippet(span).unwrap(), "BB\nCCC\nDDDDD"); // check that span_to_lines gives us the complete result with the lines/cols we expected - let lines = cm.span_to_lines(span).unwrap(); + let lines = sm.span_to_lines(span).unwrap(); let expected = vec![ LineInfo { line_index: 1, start_col: CharPos(4), end_col: CharPos(6) }, LineInfo { line_index: 2, start_col: CharPos(0), end_col: CharPos(3) }, @@ -1165,9 +1166,9 @@ mod tests { #[test] fn t8() { // Test span_to_snippet for a span ending at the end of source_file - let cm = init_code_map(); + let sm = init_source_map(); let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION); - let snippet = cm.span_to_snippet(span); + let snippet = sm.span_to_snippet(span); assert_eq!(snippet, Ok("second line".to_string())); } @@ -1175,9 +1176,9 @@ mod tests { #[test] fn t9() { // Test span_to_str for a span ending at the end of source_file - let cm = init_code_map(); + let sm = init_source_map(); let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION); - let sstr = cm.span_to_string(span); + let sstr = sm.span_to_string(span); assert_eq!(sstr, "blork.rs:2:1: 2:12"); } @@ -1185,15 +1186,15 @@ mod tests { /// Test failing to merge two spans on different lines #[test] fn span_merging_fail() { - let cm = SourceMap::new(FilePathMapping::empty()); + let sm = SourceMap::new(FilePathMapping::empty()); let inputtext = "bbbb BB\ncc CCC\n"; let selection1 = " ~~\n \n"; let selection2 = " \n ~~~\n"; - cm.new_source_file(Path::new("blork.rs").to_owned().into(), inputtext.to_owned()); + sm.new_source_file(Path::new("blork.rs").to_owned().into(), inputtext.to_owned()); let span1 = span_from_selection(inputtext, selection1); let span2 = span_from_selection(inputtext, selection2); - assert!(cm.merge_spans(span1, span2).is_none()); + assert!(sm.merge_spans(span1, span2).is_none()); } /// Returns the span corresponding to the `n`th occurrence of diff --git a/src/libsyntax/test_snippet.rs b/src/libsyntax/test_snippet.rs index d49965fd936..799489ba42c 100644 --- a/src/libsyntax/test_snippet.rs +++ b/src/libsyntax/test_snippet.rs @@ -50,8 +50,8 @@ fn test_harness(file_text: &str, span_labels: Vec, expected_output: & with_globals(|| { let output = Arc::new(Mutex::new(Vec::new())); - let code_map = Lrc::new(SourceMap::new(FilePathMapping::empty())); - code_map.new_source_file(Path::new("test.rs").to_owned().into(), file_text.to_owned()); + let source_map = Lrc::new(SourceMap::new(FilePathMapping::empty())); + source_map.new_source_file(Path::new("test.rs").to_owned().into(), file_text.to_owned()); let primary_span = make_span(&file_text, &span_labels[0].start, &span_labels[0].end); let mut msp = MultiSpan::from_span(primary_span); @@ -59,11 +59,11 @@ fn test_harness(file_text: &str, span_labels: Vec, expected_output: & let span = make_span(&file_text, &span_label.start, &span_label.end); msp.push_span_label(span, span_label.label.to_string()); println!("span: {:?} label: {:?}", span, span_label.label); - println!("text: {:?}", code_map.span_to_snippet(span)); + println!("text: {:?}", source_map.span_to_snippet(span)); } let emitter = EmitterWriter::new(Box::new(Shared { data: output.clone() }), - Some(code_map.clone()), + Some(source_map.clone()), false, false); let handler = Handler::with_emitter(true, false, Box::new(emitter)); diff --git a/src/libsyntax_pos/analyze_source_file.rs b/src/libsyntax_pos/analyze_source_file.rs index e468aaac7a3..7bc9a1af62c 100644 --- a/src/libsyntax_pos/analyze_source_file.rs +++ b/src/libsyntax_pos/analyze_source_file.rs @@ -36,9 +36,9 @@ pub fn analyze_source_file( // it encounters. If that point is already outside the source_file, remove // it again. if let Some(&last_line_start) = lines.last() { - let file_map_end = source_file_start_pos + BytePos::from_usize(src.len()); - assert!(file_map_end >= last_line_start); - if last_line_start == file_map_end { + let source_file_end = source_file_start_pos + BytePos::from_usize(src.len()); + assert!(source_file_end >= last_line_start); + if last_line_start == source_file_end { lines.pop(); } } diff --git a/src/libsyntax_pos/lib.rs b/src/libsyntax_pos/lib.rs index 639155636ed..a780a38ff96 100644 --- a/src/libsyntax_pos/lib.rs +++ b/src/libsyntax_pos/lib.rs @@ -1266,9 +1266,9 @@ pub struct LocWithOpt { // used to be structural records. Better names, anyone? #[derive(Debug)] -pub struct SourceFileAndLine { pub fm: Lrc, pub line: usize } +pub struct SourceFileAndLine { pub sf: Lrc, pub line: usize } #[derive(Debug)] -pub struct SourceFileAndBytePos { pub fm: Lrc, pub pos: BytePos } +pub struct SourceFileAndBytePos { pub sf: Lrc, pub pos: BytePos } #[derive(Copy, Clone, Debug, PartialEq, Eq)] pub struct LineInfo { @@ -1303,7 +1303,7 @@ pub struct MacroBacktrace { } // _____________________________________________________________________________ -// SpanLinesError, SpanSnippetError, DistinctSources, MalformedCodemapPositions +// SpanLinesError, SpanSnippetError, DistinctSources, MalformedSourceMapPositions // pub type FileLinesResult = Result; @@ -1318,7 +1318,7 @@ pub enum SpanLinesError { pub enum SpanSnippetError { IllFormedSpan(Span), DistinctSources(DistinctSources), - MalformedForCodemap(MalformedCodemapPositions), + MalformedForSourcemap(MalformedSourceMapPositions), SourceNotAvailable { filename: FileName } } @@ -1329,7 +1329,7 @@ pub struct DistinctSources { } #[derive(Clone, PartialEq, Eq, Debug)] -pub struct MalformedCodemapPositions { +pub struct MalformedSourceMapPositions { pub name: FileName, pub source_len: usize, pub begin_pos: BytePos, diff --git a/src/test/run-pass/imports/import-crate-with-invalid-spans/auxiliary/crate_with_invalid_spans.rs b/src/test/run-pass/imports/import-crate-with-invalid-spans/auxiliary/crate_with_invalid_spans.rs index b37533d2da7..dd26cf78fda 100644 --- a/src/test/run-pass/imports/import-crate-with-invalid-spans/auxiliary/crate_with_invalid_spans.rs +++ b/src/test/run-pass/imports/import-crate-with-invalid-spans/auxiliary/crate_with_invalid_spans.rs @@ -23,8 +23,8 @@ pub fn exported_generic(x: T, y: u32) -> (T, u32) { // The AST node for the (1 + y) expression generated by the macro will then // take it's `lo` span bound from the `1` literal in the macro-defining file // and it's `hi` bound from `y` in this file, which should be lower than the - // `lo` and even lower than the lower bound of the FileMap it is supposedly - // contained in because the FileMap for this file was allocated earlier than - // the FileMap of the macro-defining file. + // `lo` and even lower than the lower bound of the SourceFile it is supposedly + // contained in because the SourceFile for this file was allocated earlier than + // the SourceFile of the macro-defining file. return (x, add1!(y)); }