mv filemap source_file
This commit is contained in:
Donato Sciarra
parent
d6dcbcd4e1
commit
cbd0595710
|
|
@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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)?;
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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,8 +1176,8 @@ 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);
|
||||
|
|
@ -1185,11 +1185,11 @@ impl<'a, 'tcx> CrateMetadata {
|
|||
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.
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ pub struct EncodeContext<'a, 'tcx: 'a> {
|
|||
interpret_allocs_inverse: Vec<interpret::AllocId>,
|
||||
|
||||
// This is used to speed up Span encoding.
|
||||
filemap_cache: Lrc<SourceFile>,
|
||||
source_file_cache: Lrc<SourceFile>,
|
||||
}
|
||||
|
||||
macro_rules! encoder_methods {
|
||||
|
|
@ -157,13 +157,13 @@ impl<'a, 'tcx> SpecializedEncoder<Span> for EncodeContext<'a, 'tcx> {
|
|||
// The Span infrastructure should make sure that this invariant holds:
|
||||
debug_assert!(span.lo <= span.hi);
|
||||
|
||||
if !self.filemap_cache.contains(span.lo) {
|
||||
if !self.source_file_cache.contains(span.lo) {
|
||||
let codemap = self.tcx.sess.codemap();
|
||||
let filemap_index = codemap.lookup_filemap_idx(span.lo);
|
||||
self.filemap_cache = codemap.files()[filemap_index].clone();
|
||||
let source_file_index = codemap.lookup_source_file_idx(span.lo);
|
||||
self.source_file_cache = codemap.files()[source_file_index].clone();
|
||||
}
|
||||
|
||||
if !self.filemap_cache.contains(span.hi) {
|
||||
if !self.source_file_cache.contains(span.hi) {
|
||||
// Unfortunately, macro expansion still sometimes generates Spans
|
||||
// that malformed in this way.
|
||||
return TAG_INVALID_SPAN.encode(self)
|
||||
|
|
@ -339,17 +339,17 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
|
||||
fn encode_codemap(&mut self) -> LazySeq<syntax_pos::SourceFile> {
|
||||
let codemap = self.tcx.sess.codemap();
|
||||
let all_filemaps = codemap.files();
|
||||
let all_source_files = codemap.files();
|
||||
|
||||
let (working_dir, working_dir_was_remapped) = self.tcx.sess.working_dir.clone();
|
||||
|
||||
let adapted = all_filemaps.iter()
|
||||
.filter(|filemap| {
|
||||
// No need to re-export imported filemaps, as any downstream
|
||||
let adapted = all_source_files.iter()
|
||||
.filter(|source_file| {
|
||||
// No need to re-export imported source_files, as any downstream
|
||||
// crate will import them from their original source.
|
||||
!filemap.is_imported()
|
||||
!source_file.is_imported()
|
||||
})
|
||||
.map(|filemap| {
|
||||
.map(|source_file| {
|
||||
// When exporting SourceFiles, we expand all paths to absolute
|
||||
// paths because any relative paths are potentially relative to
|
||||
// a wrong directory.
|
||||
|
|
@ -357,16 +357,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
// `--remap-path-prefix` we assume the user has already set
|
||||
// things up the way they want and don't touch the path values
|
||||
// anymore.
|
||||
match filemap.name {
|
||||
match source_file.name {
|
||||
FileName::Real(ref name) => {
|
||||
if filemap.name_was_remapped ||
|
||||
if source_file.name_was_remapped ||
|
||||
(name.is_relative() && working_dir_was_remapped) {
|
||||
// This path of this SourceFile has been modified by
|
||||
// path-remapping, so we use it verbatim (and avoid cloning
|
||||
// the whole map in the process).
|
||||
filemap.clone()
|
||||
source_file.clone()
|
||||
} else {
|
||||
let mut adapted = (**filemap).clone();
|
||||
let mut adapted = (**source_file).clone();
|
||||
adapted.name = Path::new(&working_dir).join(name).into();
|
||||
adapted.name_hash = {
|
||||
let mut hasher: StableHasher<u128> = StableHasher::new();
|
||||
|
|
@ -377,7 +377,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
|
|||
}
|
||||
},
|
||||
// expanded code, not from a file
|
||||
_ => filemap.clone(),
|
||||
_ => source_file.clone(),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
|
|
@ -1842,7 +1842,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
|
|||
lazy_state: LazyState::NoNode,
|
||||
type_shorthands: Default::default(),
|
||||
predicate_shorthands: Default::default(),
|
||||
filemap_cache: tcx.sess.codemap().files()[0].clone(),
|
||||
source_file_cache: tcx.sess.codemap().files()[0].clone(),
|
||||
interpret_allocs: Default::default(),
|
||||
interpret_allocs_inverse: Default::default(),
|
||||
};
|
||||
|
|
|
|||
|
|
@ -276,7 +276,7 @@ impl<'a> SpanUtils<'a> {
|
|||
None => return true,
|
||||
};
|
||||
|
||||
//If the span comes from a fake filemap, filter it.
|
||||
//If the span comes from a fake source_file, filter it.
|
||||
if !self.sess
|
||||
.codemap()
|
||||
.lookup_char_pos(parent.lo())
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ pub fn render_with_highlighting(src: &str, class: Option<&str>,
|
|||
tooltip: Option<(&str, &str)>) -> String {
|
||||
debug!("highlighting: ================\n{}\n==============", src);
|
||||
let sess = parse::ParseSess::new(FilePathMapping::empty());
|
||||
let fm = sess.codemap().new_filemap(FileName::Custom("stdin".to_string()), src.to_string());
|
||||
let fm = sess.codemap().new_source_file(FileName::Custom("stdin".to_string()), src.to_string());
|
||||
|
||||
let mut out = Vec::new();
|
||||
if let Some((tooltip, class)) = tooltip {
|
||||
|
|
|
|||
|
|
@ -109,12 +109,12 @@ impl FileLoader for RealFileLoader {
|
|||
pub struct StableFilemapId(u128);
|
||||
|
||||
impl StableFilemapId {
|
||||
pub fn new(filemap: &SourceFile) -> StableFilemapId {
|
||||
pub fn new(source_file: &SourceFile) -> StableFilemapId {
|
||||
let mut hasher = StableHasher::new();
|
||||
|
||||
filemap.name.hash(&mut hasher);
|
||||
filemap.name_was_remapped.hash(&mut hasher);
|
||||
filemap.unmapped_path.hash(&mut hasher);
|
||||
source_file.name.hash(&mut hasher);
|
||||
source_file.name_was_remapped.hash(&mut hasher);
|
||||
source_file.unmapped_path.hash(&mut hasher);
|
||||
|
||||
StableFilemapId(hasher.finish())
|
||||
}
|
||||
|
|
@ -126,7 +126,7 @@ impl StableFilemapId {
|
|||
|
||||
pub(super) struct SourceMapFiles {
|
||||
pub(super) file_maps: Vec<Lrc<SourceFile>>,
|
||||
stable_id_to_filemap: FxHashMap<StableFilemapId, Lrc<SourceFile>>
|
||||
stable_id_to_source_file: FxHashMap<StableFilemapId, Lrc<SourceFile>>
|
||||
}
|
||||
|
||||
pub struct SourceMap {
|
||||
|
|
@ -145,7 +145,7 @@ impl SourceMap {
|
|||
SourceMap {
|
||||
files: Lock::new(SourceMapFiles {
|
||||
file_maps: Vec::new(),
|
||||
stable_id_to_filemap: FxHashMap(),
|
||||
stable_id_to_source_file: FxHashMap(),
|
||||
}),
|
||||
file_loader: Box::new(RealFileLoader),
|
||||
path_mapping,
|
||||
|
|
@ -168,7 +168,7 @@ impl SourceMap {
|
|||
SourceMap {
|
||||
files: Lock::new(SourceMapFiles {
|
||||
file_maps: Vec::new(),
|
||||
stable_id_to_filemap: FxHashMap(),
|
||||
stable_id_to_source_file: FxHashMap(),
|
||||
}),
|
||||
file_loader: file_loader,
|
||||
path_mapping,
|
||||
|
|
@ -191,15 +191,15 @@ impl SourceMap {
|
|||
} else {
|
||||
path.to_owned().into()
|
||||
};
|
||||
Ok(self.new_filemap(filename, src))
|
||||
Ok(self.new_source_file(filename, src))
|
||||
}
|
||||
|
||||
pub fn files(&self) -> LockGuard<Vec<Lrc<SourceFile>>> {
|
||||
LockGuard::map(self.files.borrow(), |files| &mut files.file_maps)
|
||||
}
|
||||
|
||||
pub fn filemap_by_stable_id(&self, stable_id: StableFilemapId) -> Option<Lrc<SourceFile>> {
|
||||
self.files.borrow().stable_id_to_filemap.get(&stable_id).map(|fm| fm.clone())
|
||||
pub fn source_file_by_stable_id(&self, stable_id: StableFilemapId) -> Option<Lrc<SourceFile>> {
|
||||
self.files.borrow().stable_id_to_source_file.get(&stable_id).map(|fm| fm.clone())
|
||||
}
|
||||
|
||||
fn next_start_pos(&self) -> usize {
|
||||
|
|
@ -211,9 +211,9 @@ impl SourceMap {
|
|||
}
|
||||
}
|
||||
|
||||
/// Creates a new filemap.
|
||||
/// Creates a new source_file.
|
||||
/// This does not ensure that only one SourceFile exists per file name.
|
||||
pub fn new_filemap(&self, filename: FileName, src: String) -> Lrc<SourceFile> {
|
||||
pub fn new_source_file(&self, filename: FileName, src: String) -> Lrc<SourceFile> {
|
||||
let start_pos = self.next_start_pos();
|
||||
|
||||
// The path is used to determine the directory for loading submodules and
|
||||
|
|
@ -230,7 +230,7 @@ impl SourceMap {
|
|||
},
|
||||
other => (other, false),
|
||||
};
|
||||
let filemap = Lrc::new(SourceFile::new(
|
||||
let source_file = Lrc::new(SourceFile::new(
|
||||
filename,
|
||||
was_remapped,
|
||||
unmapped_path,
|
||||
|
|
@ -240,17 +240,17 @@ impl SourceMap {
|
|||
|
||||
let mut files = self.files.borrow_mut();
|
||||
|
||||
files.file_maps.push(filemap.clone());
|
||||
files.stable_id_to_filemap.insert(StableFilemapId::new(&filemap), filemap.clone());
|
||||
files.file_maps.push(source_file.clone());
|
||||
files.stable_id_to_source_file.insert(StableFilemapId::new(&source_file), source_file.clone());
|
||||
|
||||
filemap
|
||||
source_file
|
||||
}
|
||||
|
||||
/// Allocates a new SourceFile representing a source file from an external
|
||||
/// crate. The source code of such an "imported filemap" is not available,
|
||||
/// crate. The source code of such an "imported source_file" is not available,
|
||||
/// but we still know enough to generate accurate debuginfo location
|
||||
/// information for things inlined from other crates.
|
||||
pub fn new_imported_filemap(&self,
|
||||
pub fn new_imported_source_file(&self,
|
||||
filename: FileName,
|
||||
name_was_remapped: bool,
|
||||
crate_of_origin: u32,
|
||||
|
|
@ -278,7 +278,7 @@ impl SourceMap {
|
|||
*swc = *swc + start_pos;
|
||||
}
|
||||
|
||||
let filemap = Lrc::new(SourceFile {
|
||||
let source_file = Lrc::new(SourceFile {
|
||||
name: filename,
|
||||
name_was_remapped,
|
||||
unmapped_path: None,
|
||||
|
|
@ -296,10 +296,10 @@ impl SourceMap {
|
|||
|
||||
let mut files = self.files.borrow_mut();
|
||||
|
||||
files.file_maps.push(filemap.clone());
|
||||
files.stable_id_to_filemap.insert(StableFilemapId::new(&filemap), filemap.clone());
|
||||
files.file_maps.push(source_file.clone());
|
||||
files.stable_id_to_source_file.insert(StableFilemapId::new(&source_file), source_file.clone());
|
||||
|
||||
filemap
|
||||
source_file
|
||||
}
|
||||
|
||||
pub fn mk_substr_filename(&self, sp: Span) -> String {
|
||||
|
|
@ -385,9 +385,9 @@ impl SourceMap {
|
|||
}
|
||||
}
|
||||
|
||||
// If the relevant filemap is empty, we don't return a line number.
|
||||
// If the relevant source_file is empty, we don't return a line number.
|
||||
pub fn lookup_line(&self, pos: BytePos) -> Result<SourceFileAndLine, Lrc<SourceFile>> {
|
||||
let idx = self.lookup_filemap_idx(pos);
|
||||
let idx = self.lookup_source_file_idx(pos);
|
||||
|
||||
let f = (*self.files.borrow().file_maps)[idx].clone();
|
||||
|
||||
|
|
@ -541,7 +541,7 @@ impl SourceMap {
|
|||
local_end.fm.start_pos)
|
||||
}));
|
||||
} else {
|
||||
self.ensure_filemap_source_present(local_begin.fm.clone());
|
||||
self.ensure_source_file_source_present(local_begin.fm.clone());
|
||||
|
||||
let start_index = local_begin.pos.to_usize();
|
||||
let end_index = local_end.pos.to_usize();
|
||||
|
|
@ -798,7 +798,7 @@ impl SourceMap {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn get_filemap(&self, filename: &FileName) -> Option<Lrc<SourceFile>> {
|
||||
pub fn get_source_file(&self, filename: &FileName) -> Option<Lrc<SourceFile>> {
|
||||
for fm in self.files.borrow().file_maps.iter() {
|
||||
if *filename == fm.name {
|
||||
return Some(fm.clone());
|
||||
|
|
@ -809,15 +809,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_filemap_idx(bpos);
|
||||
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}
|
||||
}
|
||||
|
||||
/// Converts an absolute BytePos to a CharPos relative to the filemap.
|
||||
/// 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_filemap_idx(bpos);
|
||||
let idx = self.lookup_source_file_idx(bpos);
|
||||
let map = &(*self.files.borrow().file_maps)[idx];
|
||||
|
||||
// The number of extra bytes due to multibyte chars in the SourceFile
|
||||
|
|
@ -841,13 +841,13 @@ impl SourceMap {
|
|||
CharPos(bpos.to_usize() - map.start_pos.to_usize() - total_extra_bytes as usize)
|
||||
}
|
||||
|
||||
// Return the index of the filemap (in self.files) which contains pos.
|
||||
pub fn lookup_filemap_idx(&self, pos: BytePos) -> usize {
|
||||
// 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 count = files.len();
|
||||
|
||||
// Binary search for the filemap.
|
||||
// Binary search for the source_file.
|
||||
let mut a = 0;
|
||||
let mut b = count;
|
||||
while b - a > 1 {
|
||||
|
|
@ -966,7 +966,7 @@ impl SourceMapper for SourceMap {
|
|||
}
|
||||
sp
|
||||
}
|
||||
fn ensure_filemap_source_present(&self, file_map: Lrc<SourceFile>) -> bool {
|
||||
fn ensure_source_file_source_present(&self, file_map: Lrc<SourceFile>) -> bool {
|
||||
file_map.add_external_src(
|
||||
|| match file_map.name {
|
||||
FileName::Real(ref name) => self.file_loader.read_file(name).ok(),
|
||||
|
|
@ -1025,11 +1025,11 @@ mod tests {
|
|||
|
||||
fn init_code_map() -> SourceMap {
|
||||
let cm = SourceMap::new(FilePathMapping::empty());
|
||||
cm.new_filemap(PathBuf::from("blork.rs").into(),
|
||||
cm.new_source_file(PathBuf::from("blork.rs").into(),
|
||||
"first line.\nsecond line".to_string());
|
||||
cm.new_filemap(PathBuf::from("empty.rs").into(),
|
||||
cm.new_source_file(PathBuf::from("empty.rs").into(),
|
||||
"".to_string());
|
||||
cm.new_filemap(PathBuf::from("blork2.rs").into(),
|
||||
cm.new_source_file(PathBuf::from("blork2.rs").into(),
|
||||
"first line.\nsecond line".to_string());
|
||||
cm
|
||||
}
|
||||
|
|
@ -1066,7 +1066,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn t5() {
|
||||
// Test zero-length filemaps.
|
||||
// Test zero-length source_files.
|
||||
let cm = init_code_map();
|
||||
|
||||
let loc1 = cm.lookup_char_pos(BytePos(22));
|
||||
|
|
@ -1083,9 +1083,9 @@ mod tests {
|
|||
fn init_code_map_mbc() -> SourceMap {
|
||||
let cm = SourceMap::new(FilePathMapping::empty());
|
||||
// € is a three byte utf8 char.
|
||||
cm.new_filemap(PathBuf::from("blork.rs").into(),
|
||||
cm.new_source_file(PathBuf::from("blork.rs").into(),
|
||||
"fir€st €€€€ line.\nsecond line".to_string());
|
||||
cm.new_filemap(PathBuf::from("blork2.rs").into(),
|
||||
cm.new_source_file(PathBuf::from("blork2.rs").into(),
|
||||
"first line€€.\n€ second line".to_string());
|
||||
cm
|
||||
}
|
||||
|
|
@ -1110,7 +1110,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn t7() {
|
||||
// Test span_to_lines for a span ending at the end of filemap
|
||||
// Test span_to_lines for a span ending at the end of source_file
|
||||
let cm = init_code_map();
|
||||
let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
|
||||
let file_lines = cm.span_to_lines(span).unwrap();
|
||||
|
|
@ -1138,7 +1138,7 @@ mod tests {
|
|||
let cm = SourceMap::new(FilePathMapping::empty());
|
||||
let inputtext = "aaaaa\nbbbbBB\nCCC\nDDDDDddddd\neee\n";
|
||||
let selection = " \n ~~\n~~~\n~~~~~ \n \n";
|
||||
cm.new_filemap(Path::new("blork.rs").to_owned().into(), inputtext.to_string());
|
||||
cm.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
|
||||
|
|
@ -1156,7 +1156,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn t8() {
|
||||
// Test span_to_snippet for a span ending at the end of filemap
|
||||
// Test span_to_snippet for a span ending at the end of source_file
|
||||
let cm = init_code_map();
|
||||
let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
|
||||
let snippet = cm.span_to_snippet(span);
|
||||
|
|
@ -1166,7 +1166,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn t9() {
|
||||
// Test span_to_str for a span ending at the end of filemap
|
||||
// Test span_to_str for a span ending at the end of source_file
|
||||
let cm = init_code_map();
|
||||
let span = Span::new(BytePos(12), BytePos(23), NO_EXPANSION);
|
||||
let sstr = cm.span_to_string(span);
|
||||
|
|
@ -1181,7 +1181,7 @@ mod tests {
|
|||
let inputtext = "bbbb BB\ncc CCC\n";
|
||||
let selection1 = " ~~\n \n";
|
||||
let selection2 = " \n ~~~\n";
|
||||
cm.new_filemap(Path::new("blork.rs").to_owned().into(), inputtext.to_owned());
|
||||
cm.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);
|
||||
|
||||
|
|
|
|||
|
|
@ -1563,7 +1563,7 @@ impl<'a, 'b> Folder for InvocationCollector<'a, 'b> {
|
|||
|
||||
// Add this input file to the code map to make it available as
|
||||
// dependency information
|
||||
self.cx.codemap().new_filemap(filename.into(), src);
|
||||
self.cx.codemap().new_source_file(filename.into(), src);
|
||||
|
||||
let include_info = vec![
|
||||
dummy_spanned(ast::NestedMetaItemKind::MetaItem(
|
||||
|
|
|
|||
|
|
@ -63,7 +63,7 @@ pub fn expand_column_gated(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::Token
|
|||
}
|
||||
|
||||
/// file!(): expands to the current filename */
|
||||
/// The filemap (`loc.file`) contains a bunch more information we could spit
|
||||
/// The source_file (`loc.file`) contains a bunch more information we could spit
|
||||
/// out if we wanted.
|
||||
pub fn expand_file(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenTree])
|
||||
-> Box<dyn base::MacResult+'static> {
|
||||
|
|
@ -154,7 +154,7 @@ pub fn expand_include_str(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::TokenT
|
|||
|
||||
// Add this input file to the code map to make it available as
|
||||
// dependency information
|
||||
cx.codemap().new_filemap(file.into(), src);
|
||||
cx.codemap().new_source_file(file.into(), src);
|
||||
|
||||
base::MacEager::expr(cx.expr_str(sp, interned_src))
|
||||
}
|
||||
|
|
@ -184,7 +184,7 @@ pub fn expand_include_bytes(cx: &mut ExtCtxt, sp: Span, tts: &[tokenstream::Toke
|
|||
Ok(..) => {
|
||||
// Add this input file to the code map to make it available as
|
||||
// dependency information, but don't enter it's contents
|
||||
cx.codemap().new_filemap(file.into(), "".to_string());
|
||||
cx.codemap().new_source_file(file.into(), "".to_string());
|
||||
|
||||
base::MacEager::expr(cx.expr_lit(sp, ast::LitKind::ByteStr(Lrc::new(bytes))))
|
||||
}
|
||||
|
|
|
|||
|
|
@ -340,7 +340,7 @@ impl DiagnosticSpan {
|
|||
}
|
||||
|
||||
impl DiagnosticSpanLine {
|
||||
fn line_from_filemap(fm: &syntax_pos::SourceFile,
|
||||
fn line_from_source_file(fm: &syntax_pos::SourceFile,
|
||||
index: usize,
|
||||
h_start: usize,
|
||||
h_end: usize)
|
||||
|
|
@ -362,7 +362,7 @@ impl DiagnosticSpanLine {
|
|||
lines.lines
|
||||
.iter()
|
||||
.map(|line| {
|
||||
DiagnosticSpanLine::line_from_filemap(fm,
|
||||
DiagnosticSpanLine::line_from_source_file(fm,
|
||||
line.line_index,
|
||||
line.start_col.0 + 1,
|
||||
line.end_col.0 + 1)
|
||||
|
|
|
|||
|
|
@ -247,11 +247,11 @@ fn read_block_comment(rdr: &mut StringReader,
|
|||
let mut lines: Vec<String> = Vec::new();
|
||||
|
||||
// Count the number of chars since the start of the line by rescanning.
|
||||
let mut src_index = rdr.src_index(rdr.filemap.line_begin_pos(rdr.pos));
|
||||
let mut src_index = rdr.src_index(rdr.source_file.line_begin_pos(rdr.pos));
|
||||
let end_src_index = rdr.src_index(rdr.pos);
|
||||
assert!(src_index <= end_src_index,
|
||||
"src_index={}, end_src_index={}, line_begin_pos={}",
|
||||
src_index, end_src_index, rdr.filemap.line_begin_pos(rdr.pos).to_u32());
|
||||
src_index, end_src_index, rdr.source_file.line_begin_pos(rdr.pos).to_u32());
|
||||
let mut n = 0;
|
||||
|
||||
while src_index < end_src_index {
|
||||
|
|
@ -372,8 +372,8 @@ pub fn gather_comments_and_literals(sess: &ParseSess, path: FileName, srdr: &mut
|
|||
let mut src = String::new();
|
||||
srdr.read_to_string(&mut src).unwrap();
|
||||
let cm = SourceMap::new(sess.codemap().path_mapping().clone());
|
||||
let filemap = cm.new_filemap(path, src);
|
||||
let mut rdr = lexer::StringReader::new_raw(sess, filemap, None);
|
||||
let source_file = cm.new_source_file(path, src);
|
||||
let mut rdr = lexer::StringReader::new_raw(sess, source_file, None);
|
||||
|
||||
let mut comments: Vec<Comment> = Vec::new();
|
||||
let mut literals: Vec<Literal> = Vec::new();
|
||||
|
|
|
|||
|
|
@ -49,7 +49,7 @@ pub struct StringReader<'a> {
|
|||
pub pos: BytePos,
|
||||
/// The current character (which has been read from self.pos)
|
||||
pub ch: Option<char>,
|
||||
pub filemap: Lrc<syntax_pos::SourceFile>,
|
||||
pub source_file: Lrc<syntax_pos::SourceFile>,
|
||||
/// Stop reading src at this index.
|
||||
pub end_src_index: usize,
|
||||
// cached:
|
||||
|
|
@ -58,7 +58,7 @@ pub struct StringReader<'a> {
|
|||
peek_span_src_raw: Span,
|
||||
fatal_errs: Vec<DiagnosticBuilder<'a>>,
|
||||
// cache a direct reference to the source text, so that we don't have to
|
||||
// retrieve it via `self.filemap.src.as_ref().unwrap()` all the time.
|
||||
// retrieve it via `self.source_file.src.as_ref().unwrap()` all the time.
|
||||
src: Lrc<String>,
|
||||
/// Stack of open delimiters and their spans. Used for error message.
|
||||
token: token::Token,
|
||||
|
|
@ -180,31 +180,31 @@ impl<'a> StringReader<'a> {
|
|||
}
|
||||
|
||||
/// For comments.rs, which hackily pokes into next_pos and ch
|
||||
fn new_raw(sess: &'a ParseSess, filemap: Lrc<syntax_pos::SourceFile>, override_span: Option<Span>)
|
||||
fn new_raw(sess: &'a ParseSess, source_file: Lrc<syntax_pos::SourceFile>, override_span: Option<Span>)
|
||||
-> Self
|
||||
{
|
||||
let mut sr = StringReader::new_raw_internal(sess, filemap, override_span);
|
||||
let mut sr = StringReader::new_raw_internal(sess, source_file, override_span);
|
||||
sr.bump();
|
||||
|
||||
sr
|
||||
}
|
||||
|
||||
fn new_raw_internal(sess: &'a ParseSess, filemap: Lrc<syntax_pos::SourceFile>,
|
||||
fn new_raw_internal(sess: &'a ParseSess, source_file: Lrc<syntax_pos::SourceFile>,
|
||||
override_span: Option<Span>) -> Self
|
||||
{
|
||||
if filemap.src.is_none() {
|
||||
sess.span_diagnostic.bug(&format!("Cannot lex filemap without source: {}",
|
||||
filemap.name));
|
||||
if source_file.src.is_none() {
|
||||
sess.span_diagnostic.bug(&format!("Cannot lex source_file without source: {}",
|
||||
source_file.name));
|
||||
}
|
||||
|
||||
let src = (*filemap.src.as_ref().unwrap()).clone();
|
||||
let src = (*source_file.src.as_ref().unwrap()).clone();
|
||||
|
||||
StringReader {
|
||||
sess,
|
||||
next_pos: filemap.start_pos,
|
||||
pos: filemap.start_pos,
|
||||
next_pos: source_file.start_pos,
|
||||
pos: source_file.start_pos,
|
||||
ch: Some('\n'),
|
||||
filemap,
|
||||
source_file,
|
||||
end_src_index: src.len(),
|
||||
// dummy values; not read
|
||||
peek_tok: token::Eof,
|
||||
|
|
@ -221,10 +221,10 @@ impl<'a> StringReader<'a> {
|
|||
}
|
||||
}
|
||||
|
||||
pub fn new(sess: &'a ParseSess, filemap: Lrc<syntax_pos::SourceFile>, override_span: Option<Span>)
|
||||
pub fn new(sess: &'a ParseSess, source_file: Lrc<syntax_pos::SourceFile>, override_span: Option<Span>)
|
||||
-> Self
|
||||
{
|
||||
let mut sr = StringReader::new_raw(sess, filemap, override_span);
|
||||
let mut sr = StringReader::new_raw(sess, source_file, override_span);
|
||||
if sr.advance_token().is_err() {
|
||||
sr.emit_fatal_errors();
|
||||
FatalError.raise();
|
||||
|
|
@ -364,8 +364,8 @@ impl<'a> StringReader<'a> {
|
|||
if self.is_eof() {
|
||||
self.peek_tok = token::Eof;
|
||||
let (real, raw) = self.mk_sp_and_raw(
|
||||
self.filemap.end_pos,
|
||||
self.filemap.end_pos,
|
||||
self.source_file.end_pos,
|
||||
self.source_file.end_pos,
|
||||
);
|
||||
self.peek_span = real;
|
||||
self.peek_span_src_raw = raw;
|
||||
|
|
@ -384,7 +384,7 @@ impl<'a> StringReader<'a> {
|
|||
|
||||
#[inline]
|
||||
fn src_index(&self, pos: BytePos) -> usize {
|
||||
(pos - self.filemap.start_pos).to_usize()
|
||||
(pos - self.source_file.start_pos).to_usize()
|
||||
}
|
||||
|
||||
/// Calls `f` with a string slice of the source text spanning from `start`
|
||||
|
|
@ -623,7 +623,7 @@ 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.filemap.clone());
|
||||
cmap.files.borrow_mut().file_maps.push(self.source_file.clone());
|
||||
let loc = cmap.lookup_char_pos_adj(self.pos);
|
||||
debug!("Skipping a shebang");
|
||||
if loc.line == 1 && loc.col == CharPos(0) {
|
||||
|
|
@ -1861,7 +1861,7 @@ mod tests {
|
|||
sess: &'a ParseSess,
|
||||
teststr: String)
|
||||
-> StringReader<'a> {
|
||||
let fm = cm.new_filemap(PathBuf::from("zebra.rs").into(), teststr);
|
||||
let fm = cm.new_source_file(PathBuf::from("zebra.rs").into(), teststr);
|
||||
StringReader::new(sess, fm, None)
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -171,13 +171,13 @@ crate fn parse_stmt_from_source_str(name: FileName, source: String, sess: &Parse
|
|||
pub fn parse_stream_from_source_str(name: FileName, source: String, sess: &ParseSess,
|
||||
override_span: Option<Span>)
|
||||
-> TokenStream {
|
||||
filemap_to_stream(sess, sess.codemap().new_filemap(name, source), override_span)
|
||||
source_file_to_stream(sess, sess.codemap().new_source_file(name, source), override_span)
|
||||
}
|
||||
|
||||
// Create a new parser from a source string
|
||||
pub fn new_parser_from_source_str(sess: &ParseSess, name: FileName, source: String)
|
||||
-> Parser {
|
||||
let mut parser = filemap_to_parser(sess, sess.codemap().new_filemap(name, source));
|
||||
let mut parser = source_file_to_parser(sess, sess.codemap().new_source_file(name, source));
|
||||
parser.recurse_into_file_modules = false;
|
||||
parser
|
||||
}
|
||||
|
|
@ -185,7 +185,7 @@ pub fn new_parser_from_source_str(sess: &ParseSess, name: FileName, source: Stri
|
|||
/// Create a new parser, handling errors as appropriate
|
||||
/// if the file doesn't exist
|
||||
pub fn new_parser_from_file<'a>(sess: &'a ParseSess, path: &Path) -> Parser<'a> {
|
||||
filemap_to_parser(sess, file_to_filemap(sess, path, None))
|
||||
source_file_to_parser(sess, file_to_source_file(sess, path, None))
|
||||
}
|
||||
|
||||
/// Given a session, a crate config, a path, and a span, add
|
||||
|
|
@ -196,16 +196,16 @@ crate fn new_sub_parser_from_file<'a>(sess: &'a ParseSess,
|
|||
directory_ownership: DirectoryOwnership,
|
||||
module_name: Option<String>,
|
||||
sp: Span) -> Parser<'a> {
|
||||
let mut p = filemap_to_parser(sess, file_to_filemap(sess, path, Some(sp)));
|
||||
let mut p = source_file_to_parser(sess, file_to_source_file(sess, path, Some(sp)));
|
||||
p.directory.ownership = directory_ownership;
|
||||
p.root_module_name = module_name;
|
||||
p
|
||||
}
|
||||
|
||||
/// Given a filemap and config, return a parser
|
||||
fn filemap_to_parser(sess: & ParseSess, filemap: Lrc<SourceFile>) -> Parser {
|
||||
let end_pos = filemap.end_pos;
|
||||
let mut parser = stream_to_parser(sess, filemap_to_stream(sess, filemap, None));
|
||||
/// Given a source_file and config, return a parser
|
||||
fn source_file_to_parser(sess: & ParseSess, source_file: Lrc<SourceFile>) -> Parser {
|
||||
let end_pos = source_file.end_pos;
|
||||
let mut parser = stream_to_parser(sess, source_file_to_stream(sess, source_file, None));
|
||||
|
||||
if parser.token == token::Eof && parser.span.is_dummy() {
|
||||
parser.span = Span::new(end_pos, end_pos, parser.span.ctxt());
|
||||
|
|
@ -224,11 +224,11 @@ pub fn new_parser_from_tts(sess: &ParseSess, tts: Vec<TokenTree>) -> Parser {
|
|||
// base abstractions
|
||||
|
||||
/// Given a session and a path and an optional span (for error reporting),
|
||||
/// add the path to the session's codemap and return the new filemap.
|
||||
fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
|
||||
/// add the path to the session's codemap and return the new source_file.
|
||||
fn file_to_source_file(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
|
||||
-> Lrc<SourceFile> {
|
||||
match sess.codemap().load_file(path) {
|
||||
Ok(filemap) => filemap,
|
||||
Ok(source_file) => source_file,
|
||||
Err(e) => {
|
||||
let msg = format!("couldn't read {:?}: {}", path.display(), e);
|
||||
match spanopt {
|
||||
|
|
@ -239,10 +239,10 @@ fn file_to_filemap(sess: &ParseSess, path: &Path, spanopt: Option<Span>)
|
|||
}
|
||||
}
|
||||
|
||||
/// Given a filemap, produce a sequence of token-trees
|
||||
pub fn filemap_to_stream(sess: &ParseSess, filemap: Lrc<SourceFile>, override_span: Option<Span>)
|
||||
/// Given a source_file, produce a sequence of token-trees
|
||||
pub fn source_file_to_stream(sess: &ParseSess, source_file: Lrc<SourceFile>, override_span: Option<Span>)
|
||||
-> TokenStream {
|
||||
let mut srdr = lexer::StringReader::new(sess, filemap, override_span);
|
||||
let mut srdr = lexer::StringReader::new(sess, source_file, override_span);
|
||||
srdr.real_token();
|
||||
panictry!(srdr.parse_all_token_trees())
|
||||
}
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ fn test_harness(file_text: &str, span_labels: Vec<SpanLabel>, expected_output: &
|
|||
let output = Arc::new(Mutex::new(Vec::new()));
|
||||
|
||||
let code_map = Lrc::new(SourceMap::new(FilePathMapping::empty()));
|
||||
code_map.new_filemap(Path::new("test.rs").to_owned().into(), file_text.to_owned());
|
||||
code_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);
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
use ast::{self, Ident};
|
||||
use codemap::FilePathMapping;
|
||||
use parse::{ParseSess, PResult, filemap_to_stream};
|
||||
use parse::{ParseSess, PResult, source_file_to_stream};
|
||||
use parse::{lexer, new_parser_from_source_str};
|
||||
use parse::parser::Parser;
|
||||
use ptr::P;
|
||||
|
|
@ -21,8 +21,8 @@ use std::path::PathBuf;
|
|||
/// Map a string to tts, using a made-up filename:
|
||||
pub fn string_to_stream(source_str: String) -> TokenStream {
|
||||
let ps = ParseSess::new(FilePathMapping::empty());
|
||||
filemap_to_stream(&ps, ps.codemap()
|
||||
.new_filemap(PathBuf::from("bogofile").into(), source_str), None)
|
||||
source_file_to_stream(&ps, ps.codemap()
|
||||
.new_source_file(PathBuf::from("bogofile").into(), source_str), None)
|
||||
}
|
||||
|
||||
/// Map string to parser (via tts)
|
||||
|
|
|
|||
|
|
@ -16,27 +16,27 @@ use super::*;
|
|||
///
|
||||
/// This function will use an SSE2 enhanced implementation if hardware support
|
||||
/// is detected at runtime.
|
||||
pub fn analyze_filemap(
|
||||
pub fn analyze_source_file(
|
||||
src: &str,
|
||||
filemap_start_pos: BytePos)
|
||||
source_file_start_pos: BytePos)
|
||||
-> (Vec<BytePos>, Vec<MultiByteChar>, Vec<NonNarrowChar>)
|
||||
{
|
||||
let mut lines = vec![filemap_start_pos];
|
||||
let mut lines = vec![source_file_start_pos];
|
||||
let mut multi_byte_chars = vec![];
|
||||
let mut non_narrow_chars = vec![];
|
||||
|
||||
// Calls the right implementation, depending on hardware support available.
|
||||
analyze_filemap_dispatch(src,
|
||||
filemap_start_pos,
|
||||
analyze_source_file_dispatch(src,
|
||||
source_file_start_pos,
|
||||
&mut lines,
|
||||
&mut multi_byte_chars,
|
||||
&mut non_narrow_chars);
|
||||
|
||||
// The code above optimistically registers a new line *after* each \n
|
||||
// it encounters. If that point is already outside the filemap, remove
|
||||
// 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 = filemap_start_pos + BytePos::from_usize(src.len());
|
||||
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 {
|
||||
lines.pop();
|
||||
|
|
@ -49,23 +49,23 @@ pub fn analyze_filemap(
|
|||
cfg_if! {
|
||||
if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"),
|
||||
not(stage0)))] {
|
||||
fn analyze_filemap_dispatch(src: &str,
|
||||
filemap_start_pos: BytePos,
|
||||
fn analyze_source_file_dispatch(src: &str,
|
||||
source_file_start_pos: BytePos,
|
||||
lines: &mut Vec<BytePos>,
|
||||
multi_byte_chars: &mut Vec<MultiByteChar>,
|
||||
non_narrow_chars: &mut Vec<NonNarrowChar>) {
|
||||
if is_x86_feature_detected!("sse2") {
|
||||
unsafe {
|
||||
analyze_filemap_sse2(src,
|
||||
filemap_start_pos,
|
||||
analyze_source_file_sse2(src,
|
||||
source_file_start_pos,
|
||||
lines,
|
||||
multi_byte_chars,
|
||||
non_narrow_chars);
|
||||
}
|
||||
} else {
|
||||
analyze_filemap_generic(src,
|
||||
analyze_source_file_generic(src,
|
||||
src.len(),
|
||||
filemap_start_pos,
|
||||
source_file_start_pos,
|
||||
lines,
|
||||
multi_byte_chars,
|
||||
non_narrow_chars);
|
||||
|
|
@ -78,7 +78,7 @@ cfg_if! {
|
|||
/// function falls back to the generic implementation. Otherwise it uses
|
||||
/// SSE2 intrinsics to quickly find all newlines.
|
||||
#[target_feature(enable = "sse2")]
|
||||
unsafe fn analyze_filemap_sse2(src: &str,
|
||||
unsafe fn analyze_source_file_sse2(src: &str,
|
||||
output_offset: BytePos,
|
||||
lines: &mut Vec<BytePos>,
|
||||
multi_byte_chars: &mut Vec<MultiByteChar>,
|
||||
|
|
@ -169,7 +169,7 @@ cfg_if! {
|
|||
// The slow path.
|
||||
// There are control chars in here, fallback to generic decoding.
|
||||
let scan_start = chunk_index * CHUNK_SIZE + intra_chunk_offset;
|
||||
intra_chunk_offset = analyze_filemap_generic(
|
||||
intra_chunk_offset = analyze_source_file_generic(
|
||||
&src[scan_start .. ],
|
||||
CHUNK_SIZE - intra_chunk_offset,
|
||||
BytePos::from_usize(scan_start) + output_offset,
|
||||
|
|
@ -182,7 +182,7 @@ cfg_if! {
|
|||
// There might still be a tail left to analyze
|
||||
let tail_start = chunk_count * CHUNK_SIZE + intra_chunk_offset;
|
||||
if tail_start < src.len() {
|
||||
analyze_filemap_generic(&src[tail_start as usize ..],
|
||||
analyze_source_file_generic(&src[tail_start as usize ..],
|
||||
src.len() - tail_start,
|
||||
output_offset + BytePos::from_usize(tail_start),
|
||||
lines,
|
||||
|
|
@ -193,14 +193,14 @@ cfg_if! {
|
|||
} else {
|
||||
|
||||
// The target (or compiler version) does not support SSE2 ...
|
||||
fn analyze_filemap_dispatch(src: &str,
|
||||
filemap_start_pos: BytePos,
|
||||
fn analyze_source_file_dispatch(src: &str,
|
||||
source_file_start_pos: BytePos,
|
||||
lines: &mut Vec<BytePos>,
|
||||
multi_byte_chars: &mut Vec<MultiByteChar>,
|
||||
non_narrow_chars: &mut Vec<NonNarrowChar>) {
|
||||
analyze_filemap_generic(src,
|
||||
analyze_source_file_generic(src,
|
||||
src.len(),
|
||||
filemap_start_pos,
|
||||
source_file_start_pos,
|
||||
lines,
|
||||
multi_byte_chars,
|
||||
non_narrow_chars);
|
||||
|
|
@ -211,7 +211,7 @@ cfg_if! {
|
|||
// `scan_len` determines the number of bytes in `src` to scan. Note that the
|
||||
// function can read past `scan_len` if a multi-byte character start within the
|
||||
// range but extends past it. The overflow is returned by the function.
|
||||
fn analyze_filemap_generic(src: &str,
|
||||
fn analyze_source_file_generic(src: &str,
|
||||
scan_len: usize,
|
||||
output_offset: BytePos,
|
||||
lines: &mut Vec<BytePos>,
|
||||
|
|
@ -288,7 +288,7 @@ fn analyze_filemap_generic(src: &str,
|
|||
macro_rules! test {
|
||||
(case: $test_name:ident,
|
||||
text: $text:expr,
|
||||
filemap_start_pos: $filemap_start_pos:expr,
|
||||
source_file_start_pos: $source_file_start_pos:expr,
|
||||
lines: $lines:expr,
|
||||
multi_byte_chars: $multi_byte_chars:expr,
|
||||
non_narrow_chars: $non_narrow_chars:expr,) => (
|
||||
|
|
@ -297,7 +297,7 @@ macro_rules! test {
|
|||
fn $test_name() {
|
||||
|
||||
let (lines, multi_byte_chars, non_narrow_chars) =
|
||||
analyze_filemap($text, BytePos($filemap_start_pos));
|
||||
analyze_source_file($text, BytePos($source_file_start_pos));
|
||||
|
||||
let expected_lines: Vec<BytePos> = $lines
|
||||
.into_iter()
|
||||
|
|
@ -330,7 +330,7 @@ macro_rules! test {
|
|||
test!(
|
||||
case: empty_text,
|
||||
text: "",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -339,7 +339,7 @@ test!(
|
|||
test!(
|
||||
case: newlines_short,
|
||||
text: "a\nc",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0, 2],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -348,7 +348,7 @@ test!(
|
|||
test!(
|
||||
case: newlines_long,
|
||||
text: "012345678\nabcdef012345678\na",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0, 10, 26],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -357,7 +357,7 @@ test!(
|
|||
test!(
|
||||
case: newline_and_multi_byte_char_in_same_chunk,
|
||||
text: "01234β789\nbcdef0123456789abcdef",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0, 11],
|
||||
multi_byte_chars: vec![(5, 2)],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -366,7 +366,7 @@ test!(
|
|||
test!(
|
||||
case: newline_and_control_char_in_same_chunk,
|
||||
text: "01234\u{07}6789\nbcdef0123456789abcdef",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0, 11],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![(5, 0)],
|
||||
|
|
@ -375,7 +375,7 @@ test!(
|
|||
test!(
|
||||
case: multi_byte_char_short,
|
||||
text: "aβc",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![(1, 2)],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -384,7 +384,7 @@ test!(
|
|||
test!(
|
||||
case: multi_byte_char_long,
|
||||
text: "0123456789abcΔf012345β",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![(13, 2), (22, 2)],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -393,7 +393,7 @@ test!(
|
|||
test!(
|
||||
case: multi_byte_char_across_chunk_boundary,
|
||||
text: "0123456789abcdeΔ123456789abcdef01234",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![(15, 2)],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -402,7 +402,7 @@ test!(
|
|||
test!(
|
||||
case: multi_byte_char_across_chunk_boundary_tail,
|
||||
text: "0123456789abcdeΔ....",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![(15, 2)],
|
||||
non_narrow_chars: vec![],
|
||||
|
|
@ -411,7 +411,7 @@ test!(
|
|||
test!(
|
||||
case: non_narrow_short,
|
||||
text: "0\t2",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![(1, 4)],
|
||||
|
|
@ -420,7 +420,7 @@ test!(
|
|||
test!(
|
||||
case: non_narrow_long,
|
||||
text: "01\t3456789abcdef01234567\u{07}9",
|
||||
filemap_start_pos: 0,
|
||||
source_file_start_pos: 0,
|
||||
lines: vec![0],
|
||||
multi_byte_chars: vec![],
|
||||
non_narrow_chars: vec![(2, 4), (24, 0)],
|
||||
|
|
@ -429,7 +429,7 @@ test!(
|
|||
test!(
|
||||
case: output_offset_all,
|
||||
text: "01\t345\n789abcΔf01234567\u{07}9\nbcΔf",
|
||||
filemap_start_pos: 1000,
|
||||
source_file_start_pos: 1000,
|
||||
lines: vec![0 + 1000, 7 + 1000, 27 + 1000],
|
||||
multi_byte_chars: vec![(13 + 1000, 2), (29 + 1000, 2)],
|
||||
non_narrow_chars: vec![(2 + 1000, 4), (24 + 1000, 0)],
|
||||
|
|
@ -63,7 +63,7 @@ pub use span_encoding::{Span, DUMMY_SP};
|
|||
|
||||
pub mod symbol;
|
||||
|
||||
mod analyze_filemap;
|
||||
mod analyze_source_file;
|
||||
|
||||
pub struct Globals {
|
||||
symbol_interner: Lock<symbol::Interner>,
|
||||
|
|
@ -974,7 +974,7 @@ impl SourceFile {
|
|||
let end_pos = start_pos.to_usize() + src.len();
|
||||
|
||||
let (lines, multibyte_chars, non_narrow_chars) =
|
||||
analyze_filemap::analyze_filemap(&src[..], start_pos);
|
||||
analyze_source_file::analyze_source_file(&src[..], start_pos);
|
||||
|
||||
SourceFile {
|
||||
name,
|
||||
|
|
@ -1082,7 +1082,7 @@ impl SourceFile {
|
|||
|
||||
/// Find the line containing the given position. The return value is the
|
||||
/// index into the `lines` array of this SourceFile, not the 1-based line
|
||||
/// number. If the filemap is empty or the position is located before the
|
||||
/// number. If the source_file is empty or the position is located before the
|
||||
/// first line, None is returned.
|
||||
pub fn lookup_line(&self, pos: BytePos) -> Option<usize> {
|
||||
if self.lines.len() == 0 {
|
||||
|
|
|
|||
Loading…
Reference in New Issue