use crate::intern::InternVisitor;
use serde::de::{Deserialize, Deserializer, Error, IgnoredAny, MapAccess, Visitor};
use serde::ser::{Serialize, SerializeMap, Serializer};
use std::cell::{Cell, RefCell};
use std::fmt::{self, Debug};
use std::sync::Arc;
#[derive(Default)]
pub struct SourceRange {
pub begin: SourceLocation,
pub end: SourceLocation,
}
#[derive(Default)]
pub struct SourceLocation {
pub spelling_loc: Option<BareSourceLocation>,
pub expansion_loc: Option<BareSourceLocation>,
}
#[derive(Clone, Debug)]
pub struct BareSourceLocation {
pub offset: usize,
pub file: Arc<str>,
pub line: usize,
pub presumed_file: Option<Arc<str>>,
pub presumed_line: Option<usize>,
pub col: usize,
pub tok_len: usize,
pub included_from: Option<IncludedFrom>,
pub is_macro_arg_expansion: bool,
}
#[derive(Clone, Debug)]
pub struct IncludedFrom {
pub included_from: Option<Box<IncludedFrom>>,
pub file: Arc<str>,
}
thread_local! {
static LAST_LOC_FILENAME: RefCell<Arc<str>> = RefCell::new(Arc::from(""));
static LAST_LOC_LINE: Cell<usize> = Cell::new(0);
}
pub(crate) fn thread_local_reset() {
LAST_LOC_FILENAME.with(|last_loc_filename| {
let mut last_loc_filename = last_loc_filename.borrow_mut();
if !last_loc_filename.is_empty() {
*last_loc_filename = Arc::from("");
}
});
LAST_LOC_LINE.with(|last_loc_line| last_loc_line.set(0));
}
enum SourceLocationField {
SpellingLoc,
ExpansionLoc,
Offset,
File,
Line,
PresumedFile,
PresumedLine,
Col,
TokLen,
IncludedFrom,
IsMacroArgExpansion,
}
impl<'de> Deserialize<'de> for SourceLocation {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct SourceLocationVisitor;
impl<'de> Visitor<'de> for SourceLocationVisitor {
type Value = SourceLocation;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct SourceLocation")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
match map.next_key()? {
None => Ok(SourceLocation::default()),
Some(SourceLocationField::SpellingLoc) => {
let spelling_loc: BareSourceLocation = map.next_value()?;
match map.next_key()? {
None => Err(Error::missing_field("expansionLoc")),
Some(SourceLocationField::ExpansionLoc) => {
let expansion_loc: BareSourceLocation = map.next_value()?;
Ok(SourceLocation {
spelling_loc: Some(spelling_loc),
expansion_loc: Some(expansion_loc),
})
}
Some(other) => Err(other.unexpected()),
}
}
Some(SourceLocationField::Offset) => {
let loc = de_rest_of_bare_source_location(map)?;
Ok(SourceLocation {
spelling_loc: Some(loc.clone()),
expansion_loc: Some(loc),
})
}
Some(other) => Err(other.unexpected()),
}
}
}
deserializer.deserialize_map(SourceLocationVisitor)
}
}
impl<'de> Deserialize<'de> for BareSourceLocation {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct BareSourceLocationVisitor;
impl<'de> Visitor<'de> for BareSourceLocationVisitor {
type Value = BareSourceLocation;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct BareSourceLocation")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
match map.next_key()? {
None => Err(Error::missing_field("offset")),
Some(SourceLocationField::Offset) => de_rest_of_bare_source_location(map),
Some(other) => Err(other.unexpected()),
}
}
}
deserializer.deserialize_map(BareSourceLocationVisitor)
}
}
impl<'de> Deserialize<'de> for SourceRange {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
enum SourceRangeField {
Begin,
End,
}
struct SourceRangeFieldVisitor;
impl<'de> Visitor<'de> for SourceRangeFieldVisitor {
type Value = SourceRangeField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("field identifier")
}
fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
where
E: Error,
{
static FIELDS: &[&str] = &["begin", "end"];
match field {
"begin" => Ok(SourceRangeField::Begin),
"end" => Ok(SourceRangeField::End),
_ => Err(E::unknown_field(field, FIELDS)),
}
}
}
impl<'de> Deserialize<'de> for SourceRangeField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_identifier(SourceRangeFieldVisitor)
}
}
struct SourceRangeVisitor;
impl<'de> Visitor<'de> for SourceRangeVisitor {
type Value = SourceRange;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct SourceRange")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
let mut begin = None;
let mut end = None;
while let Some(key) = map.next_key()? {
match key {
SourceRangeField::Begin => {
if begin.is_some() {
return Err(Error::duplicate_field("begin"));
}
begin = Some(map.next_value()?);
}
SourceRangeField::End => {
if end.is_some() {
return Err(Error::duplicate_field("end"));
}
end = Some(map.next_value()?);
}
}
}
let begin = begin.ok_or_else(|| Error::missing_field("begin"))?;
let end = end.ok_or_else(|| Error::missing_field("end"))?;
Ok(SourceRange { begin, end })
}
}
deserializer.deserialize_map(SourceRangeVisitor)
}
}
impl<'de> Deserialize<'de> for IncludedFrom {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
enum IncludedFromField {
IncludedFrom,
File,
}
struct IncludedFromFieldVisitor;
impl<'de> Visitor<'de> for IncludedFromFieldVisitor {
type Value = IncludedFromField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("field identifier")
}
fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
where
E: Error,
{
static FIELDS: &[&str] = &["includedFrom", "file"];
match field {
"includedFrom" => Ok(IncludedFromField::IncludedFrom),
"file" => Ok(IncludedFromField::File),
_ => Err(E::unknown_field(field, FIELDS)),
}
}
}
impl<'de> Deserialize<'de> for IncludedFromField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_identifier(IncludedFromFieldVisitor)
}
}
struct IncludedFromVisitor;
impl<'de> Visitor<'de> for IncludedFromVisitor {
type Value = IncludedFrom;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("struct IncludedFrom")
}
fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
where
M: MapAccess<'de>,
{
let mut has_included_from = false;
let mut file = None;
while let Some(key) = map.next_key()? {
match key {
IncludedFromField::IncludedFrom => {
if has_included_from {
return Err(Error::duplicate_field("includedFrom"));
}
map.next_value::<IgnoredAny>()?;
has_included_from = true;
}
IncludedFromField::File => {
if file.is_some() {
return Err(Error::duplicate_field("file"));
}
file = Some(map.next_value_seed(InternVisitor)?);
}
}
}
let file = file.ok_or_else(|| Error::missing_field("file"))?;
Ok(IncludedFrom {
included_from: None,
file,
})
}
}
deserializer.deserialize_map(IncludedFromVisitor)
}
}
impl<'de> Deserialize<'de> for SourceLocationField {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct SourceLocationFieldVisitor;
impl<'de> Visitor<'de> for SourceLocationFieldVisitor {
type Value = SourceLocationField;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
formatter.write_str("field identifier")
}
fn visit_str<E>(self, field: &str) -> Result<Self::Value, E>
where
E: Error,
{
static FIELDS: &[&str] = &[
"spellingLoc",
"expansionLoc",
"offset",
"file",
"line",
"presumedFile",
"presumedLine",
"col",
"tokLen",
"includedFrom",
"isMacroArgExpansion",
];
match field {
"spellingLoc" => Ok(SourceLocationField::SpellingLoc),
"expansionLoc" => Ok(SourceLocationField::ExpansionLoc),
"offset" => Ok(SourceLocationField::Offset),
"file" => Ok(SourceLocationField::File),
"line" => Ok(SourceLocationField::Line),
"presumedFile" => Ok(SourceLocationField::PresumedFile),
"presumedLine" => Ok(SourceLocationField::PresumedLine),
"col" => Ok(SourceLocationField::Col),
"tokLen" => Ok(SourceLocationField::TokLen),
"includedFrom" => Ok(SourceLocationField::IncludedFrom),
"isMacroArgExpansion" => Ok(SourceLocationField::IsMacroArgExpansion),
_ => Err(E::unknown_field(field, FIELDS)),
}
}
}
deserializer.deserialize_identifier(SourceLocationFieldVisitor)
}
}
fn de_rest_of_bare_source_location<'de, M>(mut map: M) -> Result<BareSourceLocation, M::Error>
where
M: MapAccess<'de>,
{
let offset: usize = map.next_value()?;
let mut file = None;
let mut line = None;
let mut presumed_file = None;
let mut presumed_line = None;
let mut col = None;
let mut tok_len = None;
let mut included_from = None;
let mut is_macro_arg_expansion = false;
while let Some(field) = map.next_key()? {
match field {
SourceLocationField::Offset => return Err(Error::duplicate_field("offset")),
SourceLocationField::File => file = Some(map.next_value_seed(InternVisitor)?),
SourceLocationField::Line => line = Some(map.next_value()?),
SourceLocationField::PresumedFile => {
presumed_file = Some(map.next_value_seed(InternVisitor)?);
}
SourceLocationField::PresumedLine => presumed_line = Some(map.next_value()?),
SourceLocationField::Col => col = Some(map.next_value()?),
SourceLocationField::TokLen => tok_len = Some(map.next_value()?),
SourceLocationField::IncludedFrom => included_from = Some(map.next_value()?),
SourceLocationField::IsMacroArgExpansion => {
is_macro_arg_expansion = map.next_value()?;
}
SourceLocationField::SpellingLoc | SourceLocationField::ExpansionLoc => {
return Err(field.unexpected());
}
}
}
let file = LAST_LOC_FILENAME.with(|last_loc_filename| match file {
Some(file) => {
*last_loc_filename.borrow_mut() = Arc::clone(&file);
file
}
None => Arc::clone(&last_loc_filename.borrow()),
});
let line = LAST_LOC_LINE.with(|last_loc_line| match line {
Some(line) => {
last_loc_line.set(line);
line
}
None => last_loc_line.get(),
});
let col = col.ok_or_else(|| Error::missing_field("col"))?;
let tok_len = tok_len.ok_or_else(|| Error::missing_field("tokLen"))?;
Ok(BareSourceLocation {
offset,
file,
line,
presumed_file,
presumed_line,
col,
tok_len,
included_from,
is_macro_arg_expansion,
})
}
impl SourceLocationField {
fn unexpected<E: Error>(&self) -> E {
Error::unknown_field(
match self {
SourceLocationField::SpellingLoc => "spellingLoc",
SourceLocationField::ExpansionLoc => "expansionLoc",
SourceLocationField::Offset => "offset",
SourceLocationField::File => "file",
SourceLocationField::Line => "line",
SourceLocationField::PresumedFile => "presumedFile",
SourceLocationField::PresumedLine => "presumedLine",
SourceLocationField::Col => "col",
SourceLocationField::TokLen => "tokLen",
SourceLocationField::IncludedFrom => "includedFrom",
SourceLocationField::IsMacroArgExpansion => "isMacroArgExpansion",
},
&[
"spellingLoc",
"expansionLoc",
"offset",
"file",
"line",
"presumedFile",
"presumedLine",
"col",
"tokLen",
"includedFrom",
"isMacroArgExpansion",
],
)
}
}
impl Serialize for SourceRange {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("begin", &self.begin)?;
map.serialize_entry("end", &self.end)?;
map.end()
}
}
impl Serialize for SourceLocation {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
fn same_bare_source_location(
spelling_loc: &BareSourceLocation,
expansion_loc: &BareSourceLocation,
) -> bool {
let BareSourceLocation {
offset: spelling_offset,
file: spelling_file,
line: spelling_line,
presumed_file: spelling_presumed_file,
presumed_line: spelling_presumed_line,
col: spelling_col,
tok_len: spelling_tok_len,
included_from: spelling_included_from,
is_macro_arg_expansion: spelling_is_macro_arg_expansion,
} = spelling_loc;
let BareSourceLocation {
offset: expansion_offset,
file: expansion_file,
line: expansion_line,
presumed_file: expansion_presumed_file,
presumed_line: expansion_presumed_line,
col: expansion_col,
tok_len: expansion_tok_len,
included_from: expansion_included_from,
is_macro_arg_expansion: expansion_is_macro_arg_expansion,
} = expansion_loc;
spelling_offset == expansion_offset
&& spelling_file == expansion_file
&& spelling_line == expansion_line
&& spelling_presumed_file == expansion_presumed_file
&& spelling_presumed_line == expansion_presumed_line
&& spelling_col == expansion_col
&& spelling_tok_len == expansion_tok_len
&& same_opt_included_from(
spelling_included_from.as_ref(),
expansion_included_from.as_ref(),
)
&& spelling_is_macro_arg_expansion == expansion_is_macro_arg_expansion
}
fn same_opt_included_from(
spelling_included_from: Option<&IncludedFrom>,
expansion_included_from: Option<&IncludedFrom>,
) -> bool {
spelling_included_from.zip(expansion_included_from).map_or(
false,
|(spelling_included_from, expansion_included_from)| {
let IncludedFrom {
included_from: spelling_included_from,
file: spelling_file,
} = spelling_included_from;
let IncludedFrom {
included_from: expansion_included_from,
file: expansion_file,
} = expansion_included_from;
same_opt_included_from(
spelling_included_from.as_ref().map(Box::as_ref),
expansion_included_from.as_ref().map(Box::as_ref),
) && spelling_file == expansion_file
},
)
}
let serialize_separately = self
.spelling_loc
.as_ref()
.zip(self.expansion_loc.as_ref())
.map_or(true, |(spelling_loc, expansion_loc)| {
!same_bare_source_location(spelling_loc, expansion_loc)
});
if serialize_separately {
let mut map = serializer.serialize_map(None)?;
if let Some(spelling_loc) = &self.spelling_loc {
map.serialize_entry("spellingLoc", spelling_loc)?;
}
if let Some(expansion_loc) = &self.expansion_loc {
map.serialize_entry("expansionLoc", expansion_loc)?;
}
map.end()
} else {
self.spelling_loc.serialize(serializer)
}
}
}
impl Serialize for BareSourceLocation {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut map = serializer.serialize_map(None)?;
map.serialize_entry("offset", &self.offset)?;
if LAST_LOC_FILENAME.with(|last_loc_filename| {
let mut last_loc_filename = last_loc_filename.borrow_mut();
if *last_loc_filename == self.file {
false
} else {
*last_loc_filename = Arc::clone(&self.file);
true
}
}) {
map.serialize_entry("file", &*self.file)?;
map.serialize_entry("line", &self.line)?;
} else if LAST_LOC_LINE.with(|last_loc_line| {
if last_loc_line.get() == self.line {
false
} else {
last_loc_line.set(self.line);
true
}
}) {
map.serialize_entry("line", &self.line)?;
}
if let Some(presumed_file) = &self.presumed_file {
map.serialize_entry("presumedFile", &**presumed_file)?;
}
if let Some(presumed_line) = &self.presumed_line {
map.serialize_entry("presumedLine", presumed_line)?;
}
map.serialize_entry("col", &self.col)?;
map.serialize_entry("tokLen", &self.tok_len)?;
if let Some(included_from) = &self.included_from {
map.serialize_entry("includedFrom", included_from)?;
}
if self.is_macro_arg_expansion {
map.serialize_entry("isMacroArgExpansion", &true)?;
}
map.end()
}
}
impl Serialize for IncludedFrom {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut map = serializer.serialize_map(None)?;
if let Some(included_from) = &self.included_from {
map.serialize_entry("includedFrom", included_from)?;
}
map.serialize_entry("file", &*self.file)?;
map.end()
}
}
impl Debug for SourceRange {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let SourceRange { begin, end } = self;
let SourceLocation {
spelling_loc: begin_spelling_loc,
expansion_loc: begin_expansion_loc,
} = begin;
let SourceLocation {
spelling_loc: end_spelling_loc,
expansion_loc: end_expansion_loc,
} = end;
let mut debug = formatter.debug_struct("SourceRange");
if begin_spelling_loc.is_some()
|| begin_expansion_loc.is_some()
|| end_spelling_loc.is_some()
|| end_expansion_loc.is_some()
{
debug.field("begin", begin).field("end", end);
}
debug.finish()
}
}
impl Debug for SourceLocation {
fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
let SourceLocation {
spelling_loc,
expansion_loc,
} = self;
let mut debug = formatter.debug_struct("SourceLocation");
if spelling_loc.is_some() {
debug.field("spelling_loc", spelling_loc);
}
if expansion_loc.is_some() {
debug.field("expansion_loc", expansion_loc);
}
debug.finish()
}
}