pub use self::hygiene::{Mark, SyntaxContext};
use crate::{rustc_data_structures::stable_hasher::StableHasher, sync::Lrc};
use serde::{Deserialize, Serialize};
use std::{
borrow::Cow,
cmp, fmt,
hash::{Hash, Hasher},
ops::{Add, Sub},
path::PathBuf,
sync::Mutex,
};
mod analyze_source_file;
pub mod hygiene;
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize)]
pub struct Span {
#[serde(rename = "start")]
pub lo: BytePos,
#[serde(rename = "end")]
pub hi: BytePos,
pub ctxt: SyntaxContext,
}
#[cfg(feature = "arbitrary")]
impl arbitrary::Arbitrary for Span {
fn arbitrary(u: &mut arbitrary::Unstructured<'_>) -> arbitrary::Result<Self> {
let lo = u.arbitrary::<BytePos>()?;
let hi = u.arbitrary::<BytePos>()?;
Ok(Self::new(lo, hi, Default::default()))
}
}
pub const DUMMY_SP: Span = Span {
lo: BytePos(0),
hi: BytePos(0),
ctxt: SyntaxContext::empty(),
};
#[derive(Default)]
pub struct Globals {
hygiene_data: Mutex<hygiene::HygieneData>,
}
impl Globals {
pub fn new() -> Globals {
Globals {
hygiene_data: Mutex::new(hygiene::HygieneData::new()),
}
}
}
pub static GLOBALS: ::scoped_tls::ScopedKey<Globals> = ::scoped_tls::ScopedKey {
inner: {
thread_local!(static FOO: ::std::cell::Cell<usize> = {
::std::cell::Cell::new(0)
});
&FOO
},
_marker: ::std::marker::PhantomData,
};
#[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
pub enum FileName {
Real(PathBuf),
Macros(String),
QuoteExpansion,
Anon,
MacroExpansion,
ProcMacroSourceCode,
Custom(String),
}
impl std::fmt::Display for FileName {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match *self {
FileName::Real(ref path) => write!(fmt, "{}", path.display()),
FileName::Macros(ref name) => write!(fmt, "<{} macros>", name),
FileName::QuoteExpansion => write!(fmt, "<quote expansion>"),
FileName::MacroExpansion => write!(fmt, "<macro expansion>"),
FileName::Anon => write!(fmt, "<anon>"),
FileName::ProcMacroSourceCode => write!(fmt, "<proc-macro source code>"),
FileName::Custom(ref s) => write!(fmt, "<{}>", s),
}
}
}
impl From<PathBuf> for FileName {
fn from(p: PathBuf) -> Self {
assert!(!p.to_string_lossy().ends_with('>'));
FileName::Real(p)
}
}
impl FileName {
pub fn is_real(&self) -> bool {
match *self {
FileName::Real(_) => true,
FileName::Macros(_)
| FileName::Anon
| FileName::MacroExpansion
| FileName::ProcMacroSourceCode
| FileName::Custom(_)
| FileName::QuoteExpansion => false,
}
}
pub fn is_macros(&self) -> bool {
match *self {
FileName::Real(_)
| FileName::Anon
| FileName::MacroExpansion
| FileName::ProcMacroSourceCode
| FileName::Custom(_)
| FileName::QuoteExpansion => false,
FileName::Macros(_) => true,
}
}
}
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub struct MultiSpan {
primary_spans: Vec<Span>,
span_labels: Vec<(Span, String)>,
}
impl Span {
#[inline]
pub fn lo(self) -> BytePos {
self.lo
}
#[inline]
pub fn new(mut lo: BytePos, mut hi: BytePos, ctxt: SyntaxContext) -> Self {
if lo > hi {
std::mem::swap(&mut lo, &mut hi);
}
Span { lo, hi, ctxt }
}
#[inline]
pub fn with_lo(&self, lo: BytePos) -> Span {
Span::new(lo, self.hi, self.ctxt)
}
#[inline]
pub fn hi(self) -> BytePos {
self.hi
}
#[inline]
pub fn with_hi(&self, hi: BytePos) -> Span {
Span::new(self.lo, hi, self.ctxt)
}
#[inline]
pub fn ctxt(self) -> SyntaxContext {
self.ctxt
}
#[inline]
pub fn with_ctxt(&self, ctxt: SyntaxContext) -> Span {
Span::new(self.lo, self.hi, ctxt)
}
#[inline]
pub fn is_dummy(self) -> bool {
self.lo.0 == 0 && self.hi.0 == 0
}
#[inline]
pub fn shrink_to_lo(self) -> Span {
self.with_hi(self.lo)
}
#[inline]
pub fn shrink_to_hi(self) -> Span {
self.with_lo(self.hi)
}
pub fn substitute_dummy(self, other: Span) -> Span {
if self.is_dummy() {
other
} else {
self
}
}
pub fn contains(self, other: Span) -> bool {
self.lo <= other.lo && other.hi <= self.hi
}
pub fn source_equal(self, other: Span) -> bool {
self.lo == other.lo && self.hi == other.hi
}
pub fn trim_start(self, other: Span) -> Option<Span> {
if self.hi > other.hi {
Some(self.with_lo(cmp::max(self.lo, other.hi)))
} else {
None
}
}
pub fn to(self, end: Span) -> Span {
let span_data = self;
let end_data = end;
if span_data.ctxt != end_data.ctxt {
if span_data.ctxt == SyntaxContext::empty() {
return end;
} else if end_data.ctxt == SyntaxContext::empty() {
return self;
}
}
Span::new(
cmp::min(span_data.lo, end_data.lo),
cmp::max(span_data.hi, end_data.hi),
if span_data.ctxt == SyntaxContext::empty() {
end_data.ctxt
} else {
span_data.ctxt
},
)
}
pub fn between(self, end: Span) -> Span {
let span = self;
Span::new(
span.hi,
end.lo,
if end.ctxt == SyntaxContext::empty() {
end.ctxt
} else {
span.ctxt
},
)
}
pub fn until(self, end: Span) -> Span {
let span = self;
Span::new(
span.lo,
end.lo,
if end.ctxt == SyntaxContext::empty() {
end.ctxt
} else {
span.ctxt
},
)
}
pub fn from_inner_byte_pos(self, start: usize, end: usize) -> Span {
let span = self;
Span::new(
span.lo + BytePos::from_usize(start),
span.lo + BytePos::from_usize(end),
span.ctxt,
)
}
#[inline]
pub fn apply_mark(self, mark: Mark) -> Span {
let span = self;
span.with_ctxt(span.ctxt.apply_mark(mark))
}
#[inline]
pub fn remove_mark(&mut self) -> Mark {
let mut span = *self;
let mark = span.ctxt.remove_mark();
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
#[inline]
pub fn adjust(&mut self, expansion: Mark) -> Option<Mark> {
let mut span = *self;
let mark = span.ctxt.adjust(expansion);
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
#[inline]
pub fn glob_adjust(
&mut self,
expansion: Mark,
glob_ctxt: SyntaxContext,
) -> Option<Option<Mark>> {
let mut span = *self;
let mark = span.ctxt.glob_adjust(expansion, glob_ctxt);
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
#[inline]
pub fn reverse_glob_adjust(
&mut self,
expansion: Mark,
glob_ctxt: SyntaxContext,
) -> Option<Option<Mark>> {
let mut span = *self;
let mark = span.ctxt.reverse_glob_adjust(expansion, glob_ctxt);
*self = Span::new(span.lo, span.hi, span.ctxt);
mark
}
}
#[derive(Clone, Debug)]
pub struct SpanLabel {
pub span: Span,
pub is_primary: bool,
pub label: Option<String>,
}
impl Default for Span {
fn default() -> Self {
DUMMY_SP
}
}
impl MultiSpan {
#[inline]
pub fn new() -> MultiSpan {
MultiSpan {
primary_spans: vec![],
span_labels: vec![],
}
}
pub fn from_span(primary_span: Span) -> MultiSpan {
MultiSpan {
primary_spans: vec![primary_span],
span_labels: vec![],
}
}
pub fn from_spans(vec: Vec<Span>) -> MultiSpan {
MultiSpan {
primary_spans: vec,
span_labels: vec![],
}
}
pub fn push_span_label(&mut self, span: Span, label: String) {
self.span_labels.push((span, label));
}
pub fn primary_span(&self) -> Option<Span> {
self.primary_spans.first().cloned()
}
pub fn primary_spans(&self) -> &[Span] {
&self.primary_spans
}
pub fn is_dummy(&self) -> bool {
let mut is_dummy = true;
for span in &self.primary_spans {
if !span.is_dummy() {
is_dummy = false;
}
}
is_dummy
}
pub fn replace(&mut self, before: Span, after: Span) -> bool {
let mut replacements_occurred = false;
for primary_span in &mut self.primary_spans {
if *primary_span == before {
*primary_span = after;
replacements_occurred = true;
}
}
for span_label in &mut self.span_labels {
if span_label.0 == before {
span_label.0 = after;
replacements_occurred = true;
}
}
replacements_occurred
}
pub fn span_labels(&self) -> Vec<SpanLabel> {
let is_primary = |span| self.primary_spans.contains(&span);
let mut span_labels = self
.span_labels
.iter()
.map(|&(span, ref label)| SpanLabel {
span,
is_primary: is_primary(span),
label: Some(label.clone()),
})
.collect::<Vec<_>>();
for &span in &self.primary_spans {
if !span_labels.iter().any(|sl| sl.span == span) {
span_labels.push(SpanLabel {
span,
is_primary: true,
label: None,
});
}
}
span_labels
}
}
impl From<Span> for MultiSpan {
fn from(span: Span) -> MultiSpan {
MultiSpan::from_span(span)
}
}
impl From<Vec<Span>> for MultiSpan {
fn from(spans: Vec<Span>) -> MultiSpan {
MultiSpan::from_spans(spans)
}
}
pub const NO_EXPANSION: SyntaxContext = SyntaxContext::empty();
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub struct MultiByteChar {
pub pos: BytePos,
pub bytes: u8,
}
#[derive(Copy, Clone, Eq, PartialEq, Debug)]
pub enum NonNarrowChar {
ZeroWidth(BytePos),
Wide(BytePos),
Tab(BytePos),
}
impl NonNarrowChar {
fn new(pos: BytePos, width: usize) -> Self {
match width {
0 => NonNarrowChar::ZeroWidth(pos),
2 => NonNarrowChar::Wide(pos),
4 => NonNarrowChar::Tab(pos),
_ => panic!("width {} given for non-narrow character", width),
}
}
pub fn pos(self) -> BytePos {
match self {
NonNarrowChar::ZeroWidth(p) | NonNarrowChar::Wide(p) | NonNarrowChar::Tab(p) => p,
}
}
pub fn width(self) -> usize {
match self {
NonNarrowChar::ZeroWidth(_) => 0,
NonNarrowChar::Wide(_) => 2,
NonNarrowChar::Tab(_) => 4,
}
}
}
impl Add<BytePos> for NonNarrowChar {
type Output = Self;
fn add(self, rhs: BytePos) -> Self {
match self {
NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos + rhs),
NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos + rhs),
NonNarrowChar::Tab(pos) => NonNarrowChar::Tab(pos + rhs),
}
}
}
impl Sub<BytePos> for NonNarrowChar {
type Output = Self;
fn sub(self, rhs: BytePos) -> Self {
match self {
NonNarrowChar::ZeroWidth(pos) => NonNarrowChar::ZeroWidth(pos - rhs),
NonNarrowChar::Wide(pos) => NonNarrowChar::Wide(pos - rhs),
NonNarrowChar::Tab(pos) => NonNarrowChar::Tab(pos - rhs),
}
}
}
#[derive(Clone)]
pub struct SourceFile {
pub name: FileName,
pub name_was_remapped: bool,
pub unmapped_path: Option<FileName>,
pub crate_of_origin: u32,
pub src: Lrc<String>,
pub src_hash: u128,
pub start_pos: BytePos,
pub end_pos: BytePos,
pub lines: Vec<BytePos>,
pub multibyte_chars: Vec<MultiByteChar>,
pub non_narrow_chars: Vec<NonNarrowChar>,
pub name_hash: u128,
}
impl fmt::Debug for SourceFile {
fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(fmt, "SourceFile({})", self.name)
}
}
impl SourceFile {
pub fn new(
name: FileName,
name_was_remapped: bool,
unmapped_path: FileName,
mut src: String,
start_pos: BytePos,
) -> SourceFile {
remove_bom(&mut src);
let src_hash = {
let mut hasher: StableHasher<u128> = StableHasher::new();
hasher.write(src.as_bytes());
hasher.finish()
};
let name_hash = {
let mut hasher: StableHasher<u128> = StableHasher::new();
name.hash(&mut hasher);
hasher.finish()
};
let end_pos = start_pos.to_usize() + src.len();
let (lines, multibyte_chars, non_narrow_chars) =
analyze_source_file::analyze_source_file(&src[..], start_pos);
SourceFile {
name,
name_was_remapped,
unmapped_path: Some(unmapped_path),
crate_of_origin: 0,
src: Lrc::new(src),
src_hash,
start_pos,
end_pos: Pos::from_usize(end_pos),
lines,
multibyte_chars,
non_narrow_chars,
name_hash,
}
}
pub fn line_begin_pos(&self, pos: BytePos) -> BytePos {
let line_index = self.lookup_line(pos).unwrap();
self.lines[line_index]
}
pub fn get_line(&self, line_number: usize) -> Option<Cow<'_, str>> {
fn get_until_newline(src: &str, begin: usize) -> &str {
let slice = &src[begin..];
match slice.find('\n') {
Some(e) => &slice[..e],
None => slice,
}
}
let begin = {
let line = if let Some(line) = self.lines.get(line_number) {
line
} else {
return None;
};
let begin: BytePos = *line - self.start_pos;
begin.to_usize()
};
Some(Cow::from(get_until_newline(&self.src, begin)))
}
pub fn is_real_file(&self) -> bool {
self.name.is_real()
}
pub fn byte_length(&self) -> u32 {
self.end_pos.0 - self.start_pos.0
}
pub fn count_lines(&self) -> usize {
self.lines.len()
}
pub fn lookup_line(&self, pos: BytePos) -> Option<usize> {
if self.lines.is_empty() {
return None;
}
let line_index = lookup_line(&self.lines[..], pos);
assert!(line_index < self.lines.len() as isize);
if line_index >= 0 {
Some(line_index as usize)
} else {
None
}
}
pub fn line_bounds(&self, line_index: usize) -> (BytePos, BytePos) {
if self.start_pos == self.end_pos {
return (self.start_pos, self.end_pos);
}
assert!(line_index < self.lines.len());
if line_index == (self.lines.len() - 1) {
(self.lines[line_index], self.end_pos)
} else {
(self.lines[line_index], self.lines[line_index + 1])
}
}
#[inline]
pub fn contains(&self, byte_pos: BytePos) -> bool {
byte_pos >= self.start_pos && byte_pos <= self.end_pos
}
}
fn remove_bom(src: &mut String) {
if src.starts_with("\u{feff}") {
src.drain(..3);
}
}
pub trait Pos {
fn from_usize(n: usize) -> Self;
fn to_usize(&self) -> usize;
fn from_u32(n: u32) -> Self;
fn to_u32(&self) -> u32;
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug, Serialize, Deserialize)]
#[serde(transparent)]
#[cfg_attr(feature = "arbitrary", derive(arbitrary::Arbitrary))]
pub struct BytePos(pub u32);
#[derive(Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
pub struct CharPos(pub usize);
impl Pos for BytePos {
#[inline(always)]
fn from_usize(n: usize) -> BytePos {
BytePos(n as u32)
}
#[inline(always)]
fn to_usize(&self) -> usize {
self.0 as usize
}
#[inline(always)]
fn from_u32(n: u32) -> BytePos {
BytePos(n)
}
#[inline(always)]
fn to_u32(&self) -> u32 {
self.0
}
}
impl Add for BytePos {
type Output = BytePos;
#[inline(always)]
fn add(self, rhs: BytePos) -> BytePos {
BytePos((self.to_usize() + rhs.to_usize()) as u32)
}
}
impl Sub for BytePos {
type Output = BytePos;
#[inline(always)]
fn sub(self, rhs: BytePos) -> BytePos {
BytePos((self.to_usize() - rhs.to_usize()) as u32)
}
}
impl Pos for CharPos {
#[inline(always)]
fn from_usize(n: usize) -> CharPos {
CharPos(n)
}
#[inline(always)]
fn to_usize(&self) -> usize {
self.0
}
#[inline(always)]
fn from_u32(n: u32) -> CharPos {
CharPos(n as usize)
}
#[inline(always)]
fn to_u32(&self) -> u32 {
self.0 as u32
}
}
impl Add for CharPos {
type Output = CharPos;
#[inline(always)]
fn add(self, rhs: CharPos) -> CharPos {
CharPos(self.to_usize() + rhs.to_usize())
}
}
impl Sub for CharPos {
type Output = CharPos;
#[inline(always)]
fn sub(self, rhs: CharPos) -> CharPos {
CharPos(self.to_usize() - rhs.to_usize())
}
}
#[derive(Debug, Clone)]
pub struct Loc {
pub file: Lrc<SourceFile>,
pub line: usize,
pub col: CharPos,
pub col_display: usize,
}
#[derive(Debug)]
pub struct LocWithOpt {
pub filename: FileName,
pub line: usize,
pub col: CharPos,
pub file: Option<Lrc<SourceFile>>,
}
#[derive(Debug)]
pub struct SourceFileAndLine {
pub sf: Lrc<SourceFile>,
pub line: usize,
}
#[derive(Debug)]
pub struct SourceFileAndBytePos {
pub sf: Lrc<SourceFile>,
pub pos: BytePos,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct LineInfo {
pub line_index: usize,
pub start_col: CharPos,
pub end_col: CharPos,
}
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub struct LineCol {
pub line: u32,
pub col: u32,
}
pub struct FileLines {
pub file: Lrc<SourceFile>,
pub lines: Vec<LineInfo>,
}
pub type FileLinesResult = Result<FileLines, SpanLinesError>;
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum SpanLinesError {
IllFormedSpan(Span),
DistinctSources(DistinctSources),
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum SpanSnippetError {
IllFormedSpan(Span),
DistinctSources(DistinctSources),
MalformedForSourcemap(MalformedSourceMapPositions),
SourceNotAvailable { filename: FileName },
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct DistinctSources {
pub begin: (FileName, BytePos),
pub end: (FileName, BytePos),
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct MalformedSourceMapPositions {
pub name: FileName,
pub source_len: usize,
pub begin_pos: BytePos,
pub end_pos: BytePos,
}
fn lookup_line(lines: &[BytePos], pos: BytePos) -> isize {
match lines.binary_search(&pos) {
Ok(line) => line as isize,
Err(line) => line as isize - 1,
}
}
#[cfg(test)]
mod tests {
use super::{lookup_line, BytePos, Span};
#[test]
fn test_lookup_line() {
let lines = &[BytePos(3), BytePos(17), BytePos(28)];
assert_eq!(lookup_line(lines, BytePos(0)), -1);
assert_eq!(lookup_line(lines, BytePos(3)), 0);
assert_eq!(lookup_line(lines, BytePos(4)), 0);
assert_eq!(lookup_line(lines, BytePos(16)), 0);
assert_eq!(lookup_line(lines, BytePos(17)), 1);
assert_eq!(lookup_line(lines, BytePos(18)), 1);
assert_eq!(lookup_line(lines, BytePos(28)), 2);
assert_eq!(lookup_line(lines, BytePos(29)), 2);
}
#[test]
fn size_of_span() {
assert_eq!(std::mem::size_of::<Span>(), 12);
}
}