#[macro_use]
extern crate quickcheck;
extern crate source_map_mappings;
extern crate vlq;
use quickcheck::{Arbitrary, Gen};
use source_map_mappings::{Bias, Error};
use std::cmp::Ordering;
use std::fmt;
use std::iter;
use std::marker::PhantomData;
trait VlqRange: 'static + Send + Copy + Clone + fmt::Debug + fmt::Display {
fn low() -> i64;
fn high() -> i64;
}
#[derive(Copy, Clone, Debug)]
struct Vlq<R>(i64, PhantomData<R>);
impl<R> Arbitrary for Vlq<R>
where
R: VlqRange,
{
fn arbitrary(g: &mut Gen) -> Self {
// Uniform-ish over [low, high), like the old `Gen::gen_range`.
let span = (R::high() as i128) - (R::low() as i128);
let offset = (u64::arbitrary(g) as i128) % span;
Vlq((R::low() as i128 + offset) as i64, PhantomData)
}
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
Box::new(self.0.shrink().map(|x| Vlq(x, PhantomData)))
}
}
impl<R> fmt::Display for Vlq<R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut v = vec![];
vlq::encode(self.0, &mut v).unwrap();
write!(f, "{}", String::from_utf8_lossy(&v))
}
}
#[derive(Clone, Debug)]
enum Mapping<R> {
Generated {
generated_column: Vlq<R>,
},
Original {
generated_column: Vlq<R>,
source: Vlq<R>,
original_line: Vlq<R>,
original_column: Vlq<R>,
},
OriginalWithName {
generated_column: Vlq<R>,
source: Vlq<R>,
original_line: Vlq<R>,
original_column: Vlq<R>,
name: Vlq<R>,
},
}
impl<R> Arbitrary for Mapping<R>
where
R: VlqRange,
{
fn arbitrary(g: &mut Gen) -> Self {
match *g.choose(&[0, 1, 2]).unwrap() {
0 => Mapping::Generated {
generated_column: Vlq::<R>::arbitrary(g),
},
1 => Mapping::Original {
generated_column: Vlq::<R>::arbitrary(g),
source: Vlq::<R>::arbitrary(g),
original_line: Vlq::<R>::arbitrary(g),
original_column: Vlq::<R>::arbitrary(g),
},
2 => Mapping::OriginalWithName {
generated_column: Vlq::<R>::arbitrary(g),
source: Vlq::<R>::arbitrary(g),
original_line: Vlq::<R>::arbitrary(g),
original_column: Vlq::<R>::arbitrary(g),
name: Vlq::<R>::arbitrary(g),
},
_ => unreachable!(),
}
}
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
match *self {
Mapping::Generated { generated_column } => Box::new(
generated_column
.shrink()
.map(|generated_column| Mapping::Generated { generated_column }),
),
Mapping::Original {
generated_column,
source,
original_line,
original_column,
} => {
let shrunkens = generated_column.shrink().zip(
source
.shrink()
.zip(original_line.shrink().zip(original_column.shrink())),
);
let shrunkens = shrunkens.map(
move |(generated_column, (source, (original_line, original_column)))| {
Mapping::Original {
generated_column,
source,
original_line,
original_column,
}
},
);
let generated = Mapping::Generated { generated_column };
Box::new(iter::once(generated).chain(shrunkens))
}
Mapping::OriginalWithName {
generated_column,
source,
original_line,
original_column,
name,
} => {
let shrunkens = generated_column.shrink().zip(
source.shrink().zip(
original_line
.shrink()
.zip(original_column.shrink().zip(name.shrink())),
),
);
let shrunkens = shrunkens.map(
move |(
generated_column,
(source, (original_line, (original_column, name))),
)| {
Mapping::OriginalWithName {
generated_column,
source,
original_line,
original_column,
name,
}
},
);
let generated = Mapping::Generated { generated_column };
let original = Mapping::Original {
generated_column,
source,
original_line,
original_column,
};
Box::new(
iter::once(generated)
.chain(iter::once(original))
.chain(shrunkens),
)
}
}
}
}
impl<R: Copy> fmt::Display for Mapping<R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
Mapping::Generated { generated_column } => generated_column.fmt(f),
Mapping::Original {
generated_column,
source,
original_line,
original_column,
} => {
generated_column.fmt(f)?;
source.fmt(f)?;
original_line.fmt(f)?;
original_column.fmt(f)
}
Mapping::OriginalWithName {
generated_column,
source,
original_line,
original_column,
name,
} => {
generated_column.fmt(f)?;
source.fmt(f)?;
original_line.fmt(f)?;
original_column.fmt(f)?;
name.fmt(f)
}
}
}
}
#[derive(Clone, Debug)]
struct GeneratedLine<R>(Vec<Mapping<R>>);
impl<R> Arbitrary for GeneratedLine<R>
where
R: VlqRange,
{
fn arbitrary(g: &mut Gen) -> Self {
GeneratedLine(Vec::arbitrary(g))
}
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
Box::new(self.0.shrink().map(|v| GeneratedLine(v)))
}
}
impl<R: Copy> fmt::Display for GeneratedLine<R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut needs_comma = false;
for m in &self.0 {
if needs_comma {
write!(f, ",")?;
}
m.fmt(f)?;
needs_comma = true;
}
Ok(())
}
}
#[derive(Clone, Debug)]
struct Mappings<R>(Vec<GeneratedLine<R>>);
impl<R> Arbitrary for Mappings<R>
where
R: VlqRange,
{
fn arbitrary(g: &mut Gen) -> Self {
Mappings(Vec::arbitrary(g))
}
fn shrink(&self) -> Box<dyn Iterator<Item = Self>> {
Box::new(self.0.shrink().map(|v| Mappings(v)))
}
}
impl<R: Copy> fmt::Display for Mappings<R> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut needs_semi = false;
for line in &self.0 {
if needs_semi {
write!(f, ";")?;
}
line.fmt(f)?;
needs_semi = true;
}
Ok(())
}
}
#[derive(Copy, Clone, Debug)]
struct FullRange;
impl fmt::Display for FullRange {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
Ok(())
}
}
impl VlqRange for FullRange {
fn low() -> i64 {
i64::MIN
}
fn high() -> i64 {
i64::MAX
}
}
#[derive(Copy, Clone, Debug)]
struct SmallPositives;
impl fmt::Display for SmallPositives {
fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
Ok(())
}
}
impl VlqRange for SmallPositives {
fn low() -> i64 {
0
}
fn high() -> i64 {
5
}
}
quickcheck! {
fn parse_without_panicking(mappings: Mappings<FullRange>) -> () {
let mappings_string = mappings.to_string();
let _ = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes());
}
fn parse_valid_mappings(mappings: Mappings<SmallPositives>) -> Result<(), Error> {
let mappings_string = mappings.to_string();
source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
Ok(())
}
fn compute_column_spans(mappings: Mappings<SmallPositives>) -> Result<(), Error> {
let mappings_string = mappings.to_string();
let mut mappings = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
// Can compute column spans without panicking.
mappings.compute_column_spans();
// And those column spans make sense.
for window in mappings.by_generated_location().windows(2) {
let this_mapping = &window[0];
let next_mapping = &window[1];
if this_mapping.generated_line == next_mapping.generated_line {
assert_eq!(this_mapping.last_generated_column.unwrap(), next_mapping.generated_column);
} else {
assert!(this_mapping.last_generated_column.is_none());
}
}
Ok(())
}
fn original_location_for(
mappings: Mappings<SmallPositives>,
line: u32,
col: u32,
lub: bool
) -> Result<(), Error> {
let mappings_string = mappings.to_string();
let mappings = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
if mappings.by_generated_location().is_empty() {
return Ok(());
}
// To make this more useful, wrap `line` and `col` around the maximum
// line and column in the mappings respectively.
let max_line = mappings.by_generated_location()
.iter()
.map(|m| m.generated_line)
.max()
.unwrap();
let max_col = mappings.by_generated_location()
.iter()
.map(|m| m.generated_column)
.max()
.unwrap();
let line = line % (max_line + 1);
let col = col % (max_col + 1);
let bias = if lub {
Bias::LeastUpperBound
} else {
Bias::GreatestLowerBound
};
// If we find a mapping, then it should either be an exact match or it
// should have the proper ordering relation to our query line/column
// based on the given bias.
if let Some(mapping) = mappings.original_location_for(line, col, bias) {
let found_line = mapping.generated_line;
let found_col = mapping.generated_column;
match line.cmp(&found_line).then(col.cmp(&found_col)) {
Ordering::Equal => {}
Ordering::Greater if bias == Bias::GreatestLowerBound => {}
Ordering::Less if bias == Bias::LeastUpperBound => {}
_ => panic!(
"Found bad location {{ line = {}, col = {} }} when \
searching for {{ line = {}, col = {} }} with bias {:?}",
found_line,
found_col,
line,
col,
bias
),
}
return Ok(())
}
// If we didn't get any result, then every mapping should not match our
// query, and should additionally be on the opposite side of ordering
// from our requested bias.
for m in mappings.by_generated_location().iter() {
match m.generated_line.cmp(&line).then(m.generated_column.cmp(&col)) {
Ordering::Equal => panic!("found matching mapping when we returned none"),
Ordering::Less => {
assert_eq!(bias, Bias::LeastUpperBound);
}
Ordering::Greater => {
assert_eq!(bias, Bias::GreatestLowerBound);
}
}
}
Ok(())
}
fn original_mappings_have_original(
mappings: Mappings<SmallPositives>
) -> Result<bool, Error> {
let mappings_string = mappings.to_string();
let mut mappings = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
Ok(mappings.by_original_location().all(|m| m.original.as_ref().is_some()))
}
fn generated_location_for(
mappings: Mappings<SmallPositives>,
source: u32,
line: u32,
col: u32,
lub: bool
) -> Result<(), Error> {
let mappings_string = mappings.to_string();
let mut mappings = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
if !mappings.by_generated_location().iter().any(|m| m.original.is_some()) {
return Ok(());
}
// To make this more useful, wrap `source`, `line`, and `col` around the
// maximums.
let max_source = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().source)
.max()
.unwrap();
let max_line = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().original_line)
.max()
.unwrap();
let max_col = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().original_column)
.max()
.unwrap();
let source = source % (max_source + 1);
let line = line % (max_line + 1);
let col = col % (max_col + 1);
let bias = if lub {
Bias::LeastUpperBound
} else {
Bias::GreatestLowerBound
};
// If we find a mapping, then it should either be an exact match or it
// should have the proper ordering relation to our query line/column
// based on the given bias.
if let Some(mapping) = mappings.generated_location_for(source, line, col, bias) {
let found_source = mapping.original.as_ref().unwrap().source;
let found_line = mapping.original.as_ref().unwrap().original_line;
let found_col = mapping.original.as_ref().unwrap().original_column;
let order = source.cmp(&found_source)
.then(line.cmp(&found_line))
.then(col.cmp(&found_col));
match order {
Ordering::Equal => {}
Ordering::Greater if bias == Bias::GreatestLowerBound => {}
Ordering::Less if bias == Bias::LeastUpperBound => {}
_ => panic!(
"Found bad location {{ line = {}, col = {} }} when \
searching for {{ line = {}, col = {} }} with bias {:?}",
found_line,
found_col,
line,
col,
bias
),
}
return Ok(())
}
// If we didn't get any result, then every mapping should not match our
// query, and should additionally be on the opposite side of ordering
// from our requested bias.
for m in mappings.by_original_location() {
let m_orig = m.original.as_ref().unwrap();
let m_source = m_orig.source;
let m_line = m_orig.original_line;
let m_col = m_orig.original_column;
let order = m_source.cmp(&source)
.then(m_line.cmp(&line))
.then(m_col.cmp(&col));
match order {
Ordering::Equal => panic!("found matching mapping when we returned none"),
Ordering::Less => {
assert_eq!(bias, Bias::LeastUpperBound);
}
Ordering::Greater => {
assert_eq!(bias, Bias::GreatestLowerBound);
}
}
}
Ok(())
}
fn all_generated_locations_for(
mappings: Mappings<SmallPositives>,
source: u32,
line: u32,
col: Option<u32>
) -> Result<(), Error> {
let mappings_string = mappings.to_string();
let mut mappings = source_map_mappings::parse_mappings::<()>(mappings_string.as_bytes())?;
if !mappings.by_generated_location().iter().any(|m| m.original.is_some()) {
return Ok(());
}
let max_source = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().source)
.max()
.unwrap();
let max_line = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().original_line)
.max()
.unwrap();
let max_col = mappings.by_original_location()
.map(|m| m.original.as_ref().unwrap().original_column)
.max()
.unwrap();
let source = source % (max_source + 1);
let mut line = line % (max_line + 1);
let mut col = if let Some(col) = col {
Some(col % (max_col + 1))
} else {
None
};
let mut count = 0;
{
let locations = mappings.all_generated_locations_for(source, line, col);
for (idx, m) in locations.into_iter().enumerate() {
count += 1;
let m_orig = m.original.as_ref().unwrap();
// `all_generated_locations_for` does fuzzy searching: it will
// slide down to the next original line if there are no mappings
// on the queried line. Ditto for columns. This is to match
// mozilla/source-map's behavior.
if idx == 0 {
if m_orig.original_line != line {
assert!(m_orig.original_line > line);
line = m_orig.original_line;
}
if let Some(c) = col {
if c != m_orig.original_column {
col = Some(m_orig.original_column);
}
}
}
assert_eq!(
m_orig.original_line,
line,
"result location's line is our query's line",
);
if let Some(col) = col {
assert_eq!(
m_orig.original_column,
col,
"result location's column is our query's column",
);
}
}
}
assert_eq!(
count,
mappings.by_original_location()
.filter(|m| {
let m_orig = m.original.as_ref().unwrap();
if m_orig.source != source || m_orig.original_line != line {
return false;
}
if let Some(col) = col {
if m_orig.original_column != col {
return false;
}
}
true
})
.count(),
"the iterator should find the right number of results"
);
Ok(())
}
}