git.delta.rocks / jrsonnet / refs/commits / 44f6e2c9e550

--- a/crates/jrsonnet-parser/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-[package]
-name = "jrsonnet-parser"
-description = "jsonnet language parser and AST"
-authors.workspace = true
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-version.workspace = true
-
-[features]
-default = []
-exp-destruct = []
-exp-null-coaelse = []
-
-[dependencies]
-jrsonnet-interner.workspace = true
-jrsonnet-gcmodule.workspace = true
-
-static_assertions.workspace = true
-
-peg.workspace = true
-
-[dev-dependencies]
-insta.workspace = true

--- a/crates/jrsonnet-parser/README.adoc
+++ /dev/null
@@ -1,3 +0,0 @@
-= jrsonnet-parser
-
-Parser for jsonnet language

--- a/crates/jrsonnet-parser/src/expr.rs
+++ /dev/null
@@ -1,493 +0,0 @@
-use std::{
-	fmt::{self, Debug, Display},
-	ops::Deref,
-	rc::Rc,
-};
-
-use jrsonnet_gcmodule::Acyclic;
-use jrsonnet_interner::IStr;
-
-use crate::{
-	function::{FunctionSignature, ParamDefault, ParamName, ParamParse},
-	source::Source,
-};
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum FieldName {
-	/// {fixed: 2}
-	Fixed(IStr),
-	/// {["dyn"+"amic"]: 3}
-	Dyn(Spanned<Expr>),
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
-#[repr(u8)]
-pub enum Visibility {
-	/// :
-	Normal,
-	/// ::
-	Hidden,
-	/// :::
-	Unhide,
-}
-
-impl Visibility {
-	pub fn is_visible(&self) -> bool {
-		matches!(self, Self::Normal | Self::Unhide)
-	}
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct AssertStmt(pub Spanned<Expr>, pub Option<Spanned<Expr>>);
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct FieldMember {
-	pub name: FieldName,
-	pub plus: bool,
-	pub params: Option<ExprParams>,
-	pub visibility: Visibility,
-	pub value: Rc<Spanned<Expr>>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub(crate) enum Member {
-	Field(FieldMember),
-	BindStmt(BindSpec),
-	AssertStmt(AssertStmt),
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
-pub enum UnaryOpType {
-	Plus,
-	Minus,
-	BitNot,
-	Not,
-}
-
-impl Display for UnaryOpType {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		use UnaryOpType::*;
-		write!(
-			f,
-			"{}",
-			match self {
-				Plus => "+",
-				Minus => "-",
-				BitNot => "~",
-				Not => "!",
-			}
-		)
-	}
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Acyclic)]
-pub enum BinaryOpType {
-	Mul,
-	Div,
-
-	/// Implemented as intrinsic, put here for completeness
-	Mod,
-
-	Add,
-	Sub,
-
-	Lhs,
-	Rhs,
-
-	Lt,
-	Gt,
-	Lte,
-	Gte,
-
-	BitAnd,
-	BitOr,
-	BitXor,
-
-	Eq,
-	Neq,
-
-	And,
-	Or,
-	#[cfg(feature = "exp-null-coaelse")]
-	NullCoaelse,
-
-	// Equialent to std.objectHasEx(a, b, true)
-	In,
-}
-
-impl Display for BinaryOpType {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		use BinaryOpType::*;
-		write!(
-			f,
-			"{}",
-			match self {
-				Mul => "*",
-				Div => "/",
-				Mod => "%",
-				Add => "+",
-				Sub => "-",
-				Lhs => "<<",
-				Rhs => ">>",
-				Lt => "<",
-				Gt => ">",
-				Lte => "<=",
-				Gte => ">=",
-				BitAnd => "&",
-				BitOr => "|",
-				BitXor => "^",
-				Eq => "==",
-				Neq => "!=",
-				And => "&&",
-				Or => "||",
-				In => "in",
-				#[cfg(feature = "exp-null-coaelse")]
-				NullCoaelse => "??",
-			}
-		)
-	}
-}
-
-/// name, default value
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct ExprParam {
-	pub destruct: Destruct,
-	pub default: Option<Rc<Spanned<Expr>>>,
-}
-
-/// Defined function parameters
-#[derive(Debug, Clone, PartialEq, Acyclic)]
-pub struct ExprParams {
-	pub exprs: Rc<Vec<ExprParam>>,
-	pub signature: FunctionSignature,
-	binds_len: usize,
-}
-impl ExprParams {
-	pub fn len(&self) -> usize {
-		self.exprs.len()
-	}
-	pub fn is_empty(&self) -> bool {
-		self.exprs.is_empty()
-	}
-
-	pub fn binds_len(&self) -> usize {
-		self.binds_len
-	}
-	pub fn new(exprs: Vec<ExprParam>) -> Self {
-		Self {
-			signature: FunctionSignature::new(
-				exprs
-					.iter()
-					.map(|p| {
-						ParamParse::new(
-							p.destruct.name(),
-							ParamDefault::exists(p.default.is_some()),
-						)
-					})
-					.collect(),
-			),
-			binds_len: exprs.iter().map(|v| v.destruct.binds_len()).sum(),
-			exprs: Rc::new(exprs),
-		}
-	}
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct ArgsDesc {
-	pub unnamed: Vec<Rc<Spanned<Expr>>>,
-	pub named: Vec<(IStr, Rc<Spanned<Expr>>)>,
-}
-impl ArgsDesc {
-	pub fn new(unnamed: Vec<Rc<Spanned<Expr>>>, named: Vec<(IStr, Rc<Spanned<Expr>>)>) -> Self {
-		Self { unnamed, named }
-	}
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Acyclic)]
-pub enum DestructRest {
-	/// ...rest
-	Keep(IStr),
-	/// ...
-	Drop,
-}
-
-#[derive(Debug, Clone, PartialEq, Acyclic)]
-pub enum Destruct {
-	Full(IStr),
-	#[cfg(feature = "exp-destruct")]
-	Skip,
-	#[cfg(feature = "exp-destruct")]
-	Array {
-		start: Vec<Destruct>,
-		rest: Option<DestructRest>,
-		end: Vec<Destruct>,
-	},
-	#[cfg(feature = "exp-destruct")]
-	Object {
-		#[allow(clippy::type_complexity)]
-		fields: Vec<(IStr, Option<Destruct>, Option<Rc<Spanned<Expr>>>)>,
-		rest: Option<DestructRest>,
-	},
-}
-impl Destruct {
-	/// Name of destructure, used for function parameter names
-	pub fn name(&self) -> ParamName {
-		match self {
-			Self::Full(name) => ParamName::Named(name.clone()),
-			#[cfg(feature = "exp-destruct")]
-			_ => ParamName::Unnamed,
-		}
-	}
-	pub fn binds_len(&self) -> usize {
-		#[cfg(feature = "exp-destruct")]
-		fn cap_rest(rest: &Option<DestructRest>) -> usize {
-			match rest {
-				Some(DestructRest::Keep(_)) => 1,
-				Some(DestructRest::Drop) => 0,
-				None => 0,
-			}
-		}
-		match self {
-			Self::Full(_) => 1,
-			#[cfg(feature = "exp-destruct")]
-			Self::Skip => 0,
-			#[cfg(feature = "exp-destruct")]
-			Self::Array { start, rest, end } => {
-				start.iter().map(Destruct::binds_len).sum::<usize>()
-					+ end.iter().map(Destruct::binds_len).sum::<usize>()
-					+ cap_rest(rest)
-			}
-			#[cfg(feature = "exp-destruct")]
-			Self::Object { fields, rest } => {
-				let mut out = 0;
-				for (_, into, _) in fields {
-					match into {
-						Some(v) => out += v.binds_len(),
-						// Field is destructured to default name
-						None => out += 1,
-					}
-				}
-				out + cap_rest(rest)
-			}
-		}
-	}
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum BindSpec {
-	Field {
-		into: Destruct,
-		value: Rc<Spanned<Expr>>,
-	},
-	Function {
-		name: IStr,
-		params: ExprParams,
-		value: Rc<Spanned<Expr>>,
-	},
-}
-impl BindSpec {
-	pub fn binds_len(&self) -> usize {
-		match self {
-			BindSpec::Field { into, .. } => into.binds_len(),
-			BindSpec::Function { .. } => 1,
-		}
-	}
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct IfSpecData(pub Spanned<Expr>);
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct ForSpecData(pub Destruct, pub Spanned<Expr>);
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum CompSpec {
-	IfSpec(IfSpecData),
-	ForSpec(ForSpecData),
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct ObjComp {
-	pub locals: Rc<Vec<BindSpec>>,
-	pub field: Rc<FieldMember>,
-	pub compspecs: Vec<CompSpec>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct ObjMembers {
-	pub locals: Rc<Vec<BindSpec>>,
-	pub asserts: Rc<Vec<AssertStmt>>,
-	pub fields: Vec<FieldMember>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum ObjBody {
-	MemberList(ObjMembers),
-	ObjComp(ObjComp),
-}
-
-#[derive(Debug, PartialEq, Eq, Clone, Copy, Acyclic)]
-pub enum LiteralType {
-	This,
-	Super,
-	Dollar,
-	Null,
-	True,
-	False,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct SliceDesc {
-	pub start: Option<Spanned<Expr>>,
-	pub end: Option<Spanned<Expr>>,
-	pub step: Option<Spanned<Expr>>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct AssertExpr {
-	pub assert: AssertStmt,
-	pub rest: Spanned<Expr>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct BinaryOp {
-	pub lhs: Spanned<Expr>,
-	pub op: BinaryOpType,
-	pub rhs: Spanned<Expr>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum ImportKind {
-	Normal,
-	Str,
-	Bin,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct IfElse {
-	pub cond: IfSpecData,
-	pub cond_then: Spanned<Expr>,
-	pub cond_else: Option<Spanned<Expr>>,
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct Slice {
-	pub value: Spanned<Expr>,
-	pub slice: SliceDesc,
-}
-
-/// Syntax base
-#[derive(Debug, PartialEq, Acyclic)]
-pub enum Expr {
-	Literal(LiteralType),
-
-	/// String value: "hello"
-	Str(IStr),
-	/// Number: 1, 2.0, 2e+20
-	Num(f64),
-	/// Variable name: test
-	Var(IStr),
-
-	/// Array of expressions: [1, 2, "Hello"]
-	Arr(Rc<Vec<Spanned<Expr>>>),
-	/// Array comprehension:
-	/// ```jsonnet
-	///  ingredients: [
-	///    { kind: kind, qty: 4 / 3 }
-	///    for kind in [
-	///      'Honey Syrup',
-	///      'Lemon Juice',
-	///      'Farmers Gin',
-	///    ]
-	///  ],
-	/// ```
-	ArrComp(Rc<Spanned<Expr>>, Vec<CompSpec>),
-
-	/// Object: {a: 2}
-	Obj(ObjBody),
-	/// Object extension: var1 {b: 2}
-	ObjExtend(Rc<Spanned<Expr>>, ObjBody),
-
-	/// -2
-	UnaryOp(UnaryOpType, Box<Spanned<Expr>>),
-	/// 2 - 2
-	BinaryOp(Box<BinaryOp>),
-	/// assert 2 == 2 : "Math is broken"
-	AssertExpr(Rc<AssertExpr>),
-	/// local a = 2; { b: a }
-	LocalExpr(Vec<BindSpec>, Box<Spanned<Expr>>),
-
-	/// import* "hello"
-	Import(ImportKind, Box<Spanned<Expr>>),
-	/// error "I'm broken"
-	ErrorStmt(Box<Spanned<Expr>>),
-	/// a(b, c)
-	Apply(Box<Spanned<Expr>>, ArgsDesc, bool),
-	/// a[b], a.b, a?.b
-	Index {
-		indexable: Box<Spanned<Expr>>,
-		parts: Vec<IndexPart>,
-	},
-	/// function(x) x
-	Function(ExprParams, Rc<Spanned<Expr>>),
-	/// if true == false then 1 else 2
-	IfElse(Box<IfElse>),
-	Slice(Box<Slice>),
-}
-
-#[derive(Debug, PartialEq, Acyclic)]
-pub struct IndexPart {
-	pub value: Spanned<Expr>,
-	#[cfg(feature = "exp-null-coaelse")]
-	pub null_coaelse: bool,
-}
-
-/// file, begin offset, end offset
-#[derive(Clone, PartialEq, Eq, Acyclic)]
-#[repr(C)]
-pub struct Span(pub Source, pub u32, pub u32);
-impl Span {
-	pub fn belongs_to(&self, other: &Span) -> bool {
-		other.0 == self.0 && other.1 <= self.1 && other.2 >= self.2
-	}
-}
-
-static_assertions::assert_eq_size!(Span, (usize, usize));
-
-impl Debug for Span {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{:?}:{:?}-{:?}", self.0, self.1, self.2)
-	}
-}
-
-#[derive(Clone, PartialEq, Acyclic)]
-pub struct Spanned<T: Acyclic>(T, Span);
-impl<T: Acyclic> Deref for Spanned<T> {
-	type Target = T;
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-impl<T: Acyclic> Spanned<T> {
-	#[inline]
-	pub fn new(v: T, s: Span) -> Self {
-		Self(v, s)
-	}
-	#[inline]
-	pub fn span(&self) -> Span {
-		self.1.clone()
-	}
-}
-
-impl<T: Debug + Acyclic> Debug for Spanned<T> {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		let expr = &**self;
-		if f.alternate() {
-			write!(f, "{:#?}", expr)?;
-		} else {
-			write!(f, "{:?}", expr)?;
-		}
-		write!(f, " from {:?}", self.span())?;
-		Ok(())
-	}
-}

--- a/crates/jrsonnet-parser/src/function.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use std::fmt;
-use std::ops::Deref;
-use std::rc::Rc;
-
-use jrsonnet_gcmodule::Acyclic;
-use jrsonnet_interner::IStr;
-
-#[derive(Clone, Acyclic, Debug, PartialEq, Eq)]
-pub enum ParamName {
-	Unnamed,
-	Named(IStr),
-}
-impl ParamName {
-	pub fn as_str(&self) -> Option<&str> {
-		match self {
-			ParamName::Unnamed => None,
-			ParamName::Named(istr) => Some(istr),
-		}
-	}
-	pub fn is_anonymous(&self) -> bool {
-		matches!(self, Self::Unnamed)
-	}
-	pub fn is_named(&self) -> bool {
-		matches!(self, Self::Named(_))
-	}
-}
-impl PartialEq<IStr> for ParamName {
-	fn eq(&self, other: &IStr) -> bool {
-		match self {
-			ParamName::Unnamed => false,
-			ParamName::Named(istr) => istr == other,
-		}
-	}
-}
-
-impl fmt::Display for ParamName {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		match &self {
-			Self::Named(v) => write!(f, "{v}"),
-			Self::Unnamed => write!(f, "<unnamed>"),
-		}
-	}
-}
-
-#[derive(Clone, Copy, Debug, Acyclic, PartialEq, Eq)]
-pub enum ParamDefault {
-	None,
-	Exists,
-	Literal(&'static str),
-}
-impl ParamDefault {
-	pub const fn exists(is_exists: bool) -> Self {
-		if is_exists {
-			Self::Exists
-		} else {
-			Self::None
-		}
-	}
-}
-impl fmt::Display for ParamDefault {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		match self {
-			ParamDefault::None => Ok(()),
-			ParamDefault::Exists => write!(f, " = <default>"),
-			ParamDefault::Literal(lit) => write!(f, " = {lit}"),
-		}
-	}
-}
-
-#[derive(Clone, Acyclic, Debug, PartialEq, Eq)]
-pub struct ParamParse {
-	name: ParamName,
-	default: ParamDefault,
-}
-impl ParamParse {
-	pub fn new(name: ParamName, default: ParamDefault) -> Self {
-		Self { name, default }
-	}
-	/// Parameter name for named call parsing
-	pub fn name(&self) -> &ParamName {
-		&self.name
-	}
-	pub fn default(&self) -> ParamDefault {
-		self.default
-	}
-	pub fn has_default(&self) -> bool {
-		!matches!(self.default, ParamDefault::None)
-	}
-}
-impl fmt::Display for ParamParse {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}{}", self.name, self.default)
-	}
-}
-
-#[derive(Debug, Clone, Acyclic, PartialEq, Eq)]
-pub struct FunctionSignature(Rc<[ParamParse]>);
-impl Deref for FunctionSignature {
-	type Target = [ParamParse];
-
-	fn deref(&self) -> &Self::Target {
-		&self.0
-	}
-}
-
-thread_local! {
-	static EMPTY_SIGNATURE: FunctionSignature = FunctionSignature::new([].into());
-}
-
-impl FunctionSignature {
-	pub fn new(v: Rc<[ParamParse]>) -> Self {
-		Self(v)
-	}
-	pub fn empty() -> Self {
-		EMPTY_SIGNATURE.with(|p| p.clone())
-	}
-}
-impl fmt::Display for FunctionSignature {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		if self.0.is_empty() {
-			return write!(f, "(/*no arguments*/)");
-		}
-		write!(f, "(")?;
-		for (i, par) in self.0.iter().enumerate() {
-			if i != 0 {
-				write!(f, ", ")?;
-			}
-			write!(f, "{par}")?;
-		}
-		write!(f, ")")
-	}
-}

--- a/crates/jrsonnet-parser/src/lib.rs
+++ /dev/null
@@ -1,553 +0,0 @@
-#![allow(clippy::redundant_closure_call, clippy::derive_partial_eq_without_eq)]
-
-use std::rc::Rc;
-
-use peg::parser;
-mod expr;
-pub use expr::*;
-pub use jrsonnet_interner::IStr;
-pub use peg;
-pub mod function;
-mod location;
-mod source;
-mod unescape;
-
-pub use location::CodeLocation;
-pub use source::{
-	Source, SourceDefaultIgnoreJpath, SourceDirectory, SourceFifo, SourceFile, SourcePath,
-	SourcePathT, SourceVirtual,
-};
-
-pub struct ParserSettings {
-	pub source: Source,
-}
-
-macro_rules! expr_bin {
-	($a:ident $op:ident $b:ident) => {
-		Expr::BinaryOp(Box::new(BinaryOp {
-			lhs: $a,
-			op: $op,
-			rhs: $b,
-		}))
-	};
-}
-macro_rules! expr_un {
-	($op:ident $a:ident) => {
-		Expr::UnaryOp($op, Box::new($a))
-	};
-}
-
-parser! {
-	grammar jsonnet_parser() for str {
-		use peg::ParseLiteral;
-
-		rule eof() = quiet!{![_]} / expected!("<eof>")
-		rule eol() = "\n" / eof()
-
-		/// Standard C-like comments
-		rule comment()
-			= "//" (!eol()[_])* eol()
-			/ "/*" (!("*/")[_])* "*/"
-			/ "#" (!eol()[_])* eol()
-
-		rule single_whitespace() = quiet!{([' ' | '\r' | '\n' | '\t'] / comment())} / expected!("<whitespace>")
-		rule _() = quiet!{([' ' | '\r' | '\n' | '\t']+) / comment()}* / expected!("<whitespace>")
-
-		/// For comma-delimited elements
-		rule comma() = quiet!{_ "," _} / expected!("<comma>")
-		rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().next().unwrap()}
-		rule digit() -> char = d:$(['0'..='9']) {d.chars().next().unwrap()}
-		rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']
-		/// Sequence of digits
-		rule uint_str() -> &'input str = a:$(digit()+ ("_" digit()+)*) { a }
-		/// Number in scientific notation format
-		rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.replace("_","").parse().map_err(|_| "<number>") }} / expected!("<number>")
-
-		/// Reserved word followed by any non-alphanumberic
-		rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()
-		rule id() -> IStr = v:$(quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")) { v.into() }
-
-		rule keyword(id: &'static str) -> ()
-			= ##parse_string_literal(id) end_of_ident()
-
-		pub rule param(s: &ParserSettings) -> expr::ExprParam = destruct:destruct(s) expr:(_ "=" _ expr:expr(s){expr})? { expr::ExprParam { destruct, default: expr.map(Rc::new) } }
-		pub rule params(s: &ParserSettings) -> expr::ExprParams
-			= params:param(s) ** comma() comma()? { expr::ExprParams::new(params) }
-			/ { expr::ExprParams::new(Vec::new()) }
-
-		pub rule arg(s: &ParserSettings) -> (Option<IStr>, Rc<Spanned<Expr>>)
-			= name:(quiet! { (s:id() _ "=" !['='] _ {s})? } / expected!("<argument name>")) expr:expr(s) {(name, Rc::new(expr))}
-
-		pub rule args(s: &ParserSettings) -> expr::ArgsDesc
-			= args:arg(s)**comma() comma()? {?
-				let unnamed_count = args.iter().take_while(|(n, _)| n.is_none()).count();
-				let mut unnamed = Vec::with_capacity(unnamed_count);
-				let mut named = Vec::with_capacity(args.len() - unnamed_count);
-				let mut named_started = false;
-				for (name, value) in args {
-					if let Some(name) = name {
-						named_started = true;
-						named.push((name, value));
-					} else {
-						if named_started {
-							return Err("<named argument>")
-						}
-						unnamed.push(value);
-					}
-				}
-				Ok(expr::ArgsDesc::new(unnamed, named))
-			}
-
-		pub rule destruct_rest() -> expr::DestructRest
-			= "..." into:(_ into:id() {into})? {if let Some(into) = into {
-				expr::DestructRest::Keep(into)
-			} else {expr::DestructRest::Drop}}
-		pub rule destruct_array(s: &ParserSettings) -> expr::Destruct
-			= "[" _ start:destruct(s)**comma() rest:(
-				comma() _ rest:destruct_rest()? end:(
-					comma() end:destruct(s)**comma() (_ comma())? {end}
-					/ comma()? {Vec::new()}
-				) {(rest, end)}
-				/ comma()? {(None, Vec::new())}
-			) _ "]" {?
-				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Array {
-					start,
-					rest: rest.0,
-					end: rest.1,
-				});
-				#[cfg(not(feature = "exp-destruct"))] Err("!!!experimental destructuring was not enabled")
-			}
-		pub rule destruct_object(s: &ParserSettings) -> expr::Destruct
-			= "{" _
-				fields:(name:id() into:(_ ":" _ into:destruct(s) {into})? default:(_ "=" _ v:expr(s) {v})? {(name, into, default.map(Rc::new))})**comma()
-				rest:(
-					comma() rest:destruct_rest()? {rest}
-					/ comma()? {None}
-				)
-			_ "}" {?
-				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Object {
-					fields,
-					rest,
-				});
-				#[cfg(not(feature = "exp-destruct"))] Err("!!!experimental destructuring was not enabled")
-			}
-		pub rule destruct(s: &ParserSettings) -> expr::Destruct
-			= v:id() {expr::Destruct::Full(v)}
-			/ "?" {?
-				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Skip);
-				#[cfg(not(feature = "exp-destruct"))] Err("!!!experimental destructuring was not enabled")
-			}
-			/ arr:destruct_array(s) {arr}
-			/ obj:destruct_object(s) {obj}
-
-		pub rule bind(s: &ParserSettings) -> expr::BindSpec
-			= into:destruct(s) _ "=" _ value:expr(s) {expr::BindSpec::Field{into, value: Rc::new(value)}}
-			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {expr::BindSpec::Function{name, params, value: Rc::new(value)}}
-
-		pub rule assertion(s: &ParserSettings) -> expr::AssertStmt
-			= keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }
-
-		pub rule whole_line() -> &'input str
-			= str:$((!['\n'][_])* "\n") {str}
-		pub rule string_block() -> String
-			= "|||" chomped:"-"? (!['\n']single_whitespace())* "\n"
-			empty_lines:$(['\n']*)
-			prefix:[' ' | '\t']+ first_line:whole_line()
-			lines:("\n" {"\n"} / [' ' | '\t']*<{prefix.len()}> s:whole_line() {s})*
-			[' ' | '\t']*<, {prefix.len() - 1}> "|||"
-			{
-				let mut l = empty_lines.to_owned();
-				l.push_str(first_line);
-				l.extend(lines);
-				if chomped.is_some() {
-					debug_assert!(l.ends_with('\n'));
-					l.truncate(l.len() - 1);
-				}
-				l
-			}
-
-		rule hex_char()
-			= quiet! { ['0'..='9' | 'a'..='f' | 'A'..='F'] } / expected!("<hex char>")
-
-		rule string_char(c: rule<()>)
-			= (!['\\']!c()[_])+
-			/ "\\\\"
-			/ "\\u" hex_char() hex_char() hex_char() hex_char()
-			/ "\\x" hex_char() hex_char()
-			/ ['\\'] (quiet! { ['b' | 'f' | 'n' | 'r' | 't' | '"' | '\''] } / expected!("<escape character>"))
-		pub rule string() -> String
-			= ['"'] str:$(string_char(<"\"">)*) ['"'] {? unescape::unescape(str).ok_or("<escaped string>")}
-			/ ['\''] str:$(string_char(<"\'">)*) ['\''] {? unescape::unescape(str).ok_or("<escaped string>")}
-			/ quiet!{ "@'" str:$(("''" / (!['\''][_]))*) "'" {str.replace("''", "'")}
-			/ "@\"" str:$(("\"\"" / (!['"'][_]))*) "\"" {str.replace("\"\"", "\"")}
-			/ string_block() } / expected!("<string>")
-
-		pub rule field_name(s: &ParserSettings) -> expr::FieldName
-			= name:id() {expr::FieldName::Fixed(name)}
-			/ name:string() {expr::FieldName::Fixed(name.into())}
-			/ "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}
-		pub rule visibility() -> expr::Visibility
-			= ":::" {expr::Visibility::Unhide}
-			/ "::" {expr::Visibility::Hidden}
-			/ ":" {expr::Visibility::Normal}
-		pub rule field(s: &ParserSettings) -> expr::FieldMember
-			= name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {expr::FieldMember{
-				name,
-				plus: plus.is_some(),
-				params: None,
-				visibility,
-				value: Rc::new(value),
-			}}
-			/ name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {expr::FieldMember{
-				name,
-				plus: false,
-				params: Some(params),
-				visibility,
-				value: Rc::new(value),
-			}}
-		pub rule obj_local(s: &ParserSettings) -> BindSpec
-			= keyword("local") _ bind:bind(s) {bind}
-		pub rule member(s: &ParserSettings) -> expr::Member
-			= bind:obj_local(s) {expr::Member::BindStmt(bind)}
-			/ assertion:assertion(s) {expr::Member::AssertStmt(assertion)}
-			/ field:field(s) {expr::Member::Field(field)}
-		pub rule objinside(s: &ParserSettings) -> expr::ObjBody
-			= pre_locals:(b: obj_local(s) comma() {b})* &"[" field:field(s) post_locals:(comma() b:obj_local(s) {b})* _ ("," _)? forspec:forspec(s) others:(_ rest:compspec(s) {rest})? {
-				let mut compspecs = vec![CompSpec::ForSpec(forspec)];
-				compspecs.extend(others.unwrap_or_default());
-				let mut locals = pre_locals;
-				locals.extend(post_locals);
-				expr::ObjBody::ObjComp(expr::ObjComp{
-					locals: Rc::new(locals),
-					field: Rc::new(field),
-					compspecs,
-				})
-			}
-			/ members:(member(s) ** comma()) comma()? {
-				let mut locals = Vec::new();
-				let mut asserts = Vec::new();
-				let mut fields = Vec::new();
-				for member in members {
-					match member {
-						Member::Field(field_member) => fields.push(field_member),
-						Member::BindStmt(bind_spec) => locals.push(bind_spec),
-						Member::AssertStmt(assert_stmt) => asserts.push(assert_stmt),
-					}
-				}
-				expr::ObjBody::MemberList(ObjMembers {
-					locals: Rc::new(locals), asserts: Rc::new(asserts), fields
-				})
-			}
-		pub rule ifspec(s: &ParserSettings) -> IfSpecData
-			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}
-		pub rule forspec(s: &ParserSettings) -> ForSpecData
-			= keyword("for") _ id:destruct(s) _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}
-		pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec>
-			= s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} ) ** _ {s}
-		pub rule local_expr(s: &ParserSettings) -> Expr
-			= keyword("local") _ binds:bind(s) ** comma() (_ ",")? _ ";" _ expr:expr(s) { Expr::LocalExpr(binds, Box::new(expr)) }
-		pub rule string_expr(s: &ParserSettings) -> Expr
-			= s:string() {Expr::Str(s.into())}
-		pub rule obj_expr(s: &ParserSettings) -> Expr
-			= "{" _ body:objinside(s) _ "}" {Expr::Obj(body)}
-		pub rule array_expr(s: &ParserSettings) -> Expr
-			= "[" _ elems:(expr(s) ** comma()) _ comma()? "]" {Expr::Arr(Rc::new(elems))}
-		pub rule array_comp_expr(s: &ParserSettings) -> Expr
-			= "[" _ expr:expr(s) _ comma()? _ forspec:forspec(s) _ others:(others: compspec(s) _ {others})? "]" {
-				let mut specs = vec![CompSpec::ForSpec(forspec)];
-				specs.extend(others.unwrap_or_default());
-				Expr::ArrComp(Rc::new(expr), specs)
-			}
-		pub rule number_expr(s: &ParserSettings) -> Expr
-			= n:number() {? if n.is_finite() {
-				Ok(expr::Expr::Num(n))
-			} else {
-				Err("!!!numbers are finite")
-			}}
-		pub rule var_expr(s: &ParserSettings) -> Expr
-			= n:id() { expr::Expr::Var(n) }
-		pub rule id_loc(s: &ParserSettings) -> Spanned<Expr>
-			= a:position!() n:id() b:position!() { Spanned::new(expr::Expr::Str(n), Span(s.source.clone(), a as u32,b as u32)) }
-		pub rule if_then_else_expr(s: &ParserSettings) -> Expr
-			= cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse(Box::new(IfElse{
-				cond,
-				cond_then,
-				cond_else,
-			}))}
-
-		pub rule literal(s: &ParserSettings) -> Expr
-			= v:(
-				keyword("null") {LiteralType::Null}
-				/ keyword("true") {LiteralType::True}
-				/ keyword("false") {LiteralType::False}
-				/ keyword("self") {LiteralType::This}
-				/ keyword("$") {LiteralType::Dollar}
-				/ keyword("super") {LiteralType::Super}
-			) {Expr::Literal(v)}
-
-		rule import_kind() -> ImportKind
-			= keyword("importstr") { ImportKind::Str }
-			/ keyword("importbin") { ImportKind::Bin }
-			/ keyword("import") { ImportKind::Normal }
-
-		pub rule expr_basic(s: &ParserSettings) -> Expr
-			= literal(s)
-
-			/ string_expr(s) / number_expr(s)
-			/ array_expr(s)
-			/ obj_expr(s)
-			/ array_expr(s)
-			/ array_comp_expr(s)
-
-			/ kind:import_kind() _ path:expr(s) {Expr::Import(kind, Box::new(path))}
-
-			/ var_expr(s)
-			/ local_expr(s)
-			/ if_then_else_expr(s)
-
-			/ keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, Rc::new(expr))}
-			/ assert:assertion(s) _ ";" _ rest:expr(s) { Expr::AssertExpr(Rc::new(AssertExpr{
-				assert, rest
-			})) }
-
-			/ keyword("error") _ expr:expr(s) { Expr::ErrorStmt(Box::new(expr)) }
-
-		rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>
-			= _ e:(e:expr(s) _{e})? {e}
-		pub rule slice_desc(s: &ParserSettings) -> SliceDesc
-			= start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {
-				let (end, step) = if let Some((end, step)) = pair {
-					(end, step)
-				}else{
-					(None, None)
-				};
-
-				SliceDesc { start, end, step }
-			}
-
-		rule binop(x: rule<()>) -> ()
-			= quiet!{ x() } / expected!("<binary op>")
-		rule unaryop(x: rule<()>) -> ()
-			= quiet!{ x() } / expected!("<unary op>")
-
-		rule ensure_null_coaelse()
-			= "" {?
-				#[cfg(not(feature = "exp-null-coaelse"))] return Err("!!!experimental null coaelscing was not enabled");
-				#[cfg(feature = "exp-null-coaelse")] Ok(())
-			}
-		use BinaryOpType::*;
-		use UnaryOpType::*;
-		rule expr(s: &ParserSettings) -> Spanned<Expr>
-			= precedence! {
-				"(" _ e:expr(s) _ ")" {e}
-				start:position!() v:@ end:position!() { Spanned::new(v, Span(s.source.clone(), start as u32, end as u32)) }
-				--
-				a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}
-				a:(@) _ binop(<"??">) _ ensure_null_coaelse() b:@ {
-					#[cfg(feature = "exp-null-coaelse")] return expr_bin!(a NullCoaelse b);
-					unreachable!("ensure_null_coaelse will fail if feature is not enabled")
-				}
-				--
-				a:(@) _ binop(<"&&">) _ b:@ {expr_bin!(a And b)}
-				--
-				a:(@) _ binop(<"|">) _ b:@ {expr_bin!(a BitOr b)}
-				--
-				a:@ _ binop(<"^">) _ b:(@) {expr_bin!(a BitXor b)}
-				--
-				a:(@) _ binop(<"&">) _ b:@ {expr_bin!(a BitAnd b)}
-				--
-				a:(@) _ binop(<"==">) _ b:@ {expr_bin!(a Eq b)}
-				a:(@) _ binop(<"!=">) _ b:@ {expr_bin!(a Neq b)}
-				--
-				a:(@) _ binop(<"<">) _ b:@ {expr_bin!(a Lt b)}
-				a:(@) _ binop(<">">) _ b:@ {expr_bin!(a Gt b)}
-				a:(@) _ binop(<"<=">) _ b:@ {expr_bin!(a Lte b)}
-				a:(@) _ binop(<">=">) _ b:@ {expr_bin!(a Gte b)}
-				a:(@) _ binop(<keyword("in")>) _ b:@ {expr_bin!(a In b)}
-				--
-				a:(@) _ binop(<"<<">) _ b:@ {expr_bin!(a Lhs b)}
-				a:(@) _ binop(<">>">) _ b:@ {expr_bin!(a Rhs b)}
-				--
-				a:(@) _ binop(<"+">) _ b:@ {expr_bin!(a Add b)}
-				a:(@) _ binop(<"-">) _ b:@ {expr_bin!(a Sub b)}
-				--
-				a:(@) _ binop(<"*">) _ b:@ {expr_bin!(a Mul b)}
-				a:(@) _ binop(<"/">) _ b:@ {expr_bin!(a Div b)}
-				a:(@) _ binop(<"%">) _ b:@ {expr_bin!(a Mod b)}
-				--
-						unaryop(<"+">) _ b:@ {expr_un!(Plus b)}
-						unaryop(<"-">) _ b:@ {expr_un!(Minus b)}
-						unaryop(<"!">) _ b:@ {expr_un!(Not b)}
-						unaryop(<"~">) _ b:@ {expr_un!(BitNot b)}
-				--
-				value:(@) _ "[" _ slice:slice_desc(s) _ "]" {Expr::Slice(Box::new(Slice{value, slice}))}
-				indexable:(@) _ parts:index_part(s)+ {Expr::Index{indexable: Box::new(indexable), parts}}
-				a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(Box::new(a), args, ts.is_some())}
-				a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(Rc::new(a), body)}
-				--
-				e:expr_basic(s) {e}
-			}
-		pub rule index_part(s: &ParserSettings) -> IndexPart
-		= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {
-			value,
-			#[cfg(feature = "exp-null-coaelse")]
-			null_coaelse: n.is_some(),
-		}}
-		/ n:("?" _ "." _ ensure_null_coaelse())? "[" _ value:expr(s) _ "]" {IndexPart {
-			value,
-			#[cfg(feature = "exp-null-coaelse")]
-			null_coaelse: n.is_some(),
-		}}
-
-		pub rule jsonnet(s: &ParserSettings) -> Spanned<Expr> = _ e:expr(s) _ {e}
-	}
-}
-
-pub type ParseError = peg::error::ParseError<peg::str::LineCol>;
-pub fn parse(str: &str, settings: &ParserSettings) -> Result<Spanned<Expr>, ParseError> {
-	jsonnet_parser::jsonnet(str, settings)
-}
-/// Used for importstr values
-pub fn string_to_expr(str: IStr, settings: &ParserSettings) -> Spanned<Expr> {
-	let len = str.len();
-	Spanned::new(Expr::Str(str), Span(settings.source.clone(), 0, len as u32))
-}
-
-#[cfg(test)]
-pub mod tests {
-	use insta::assert_snapshot;
-	use jrsonnet_interner::IStr;
-
-	use super::parse;
-	use crate::{source::Source, ParserSettings};
-
-	fn parsep(s: &str) -> String {
-		let v = parse(
-			s,
-			&ParserSettings {
-				source: Source::new_virtual("<test>".into(), IStr::empty()),
-			},
-		)
-		.unwrap();
-		format!("{v:#?}")
-	}
-
-	macro_rules! parse {
-		($s:expr) => {
-			assert_snapshot!(parsep($s));
-		};
-	}
-
-	#[test]
-	fn multiline_string() {
-		parse!("|||\n    Hello world!\n     a\n|||");
-		parse!("|||\n  Hello world!\n   a\n|||");
-		parse!("|||\n\t\tHello world!\n\t\t\ta\n|||");
-		parse!("|||\n   Hello world!\n    a\n |||");
-	}
-
-	#[test]
-	fn slice() {
-		parse!("a[1:]");
-		parse!("a[1::]");
-		parse!("a[:1:]");
-		parse!("a[::1]");
-		parse!("str[:len - 1]");
-	}
-
-	#[test]
-	fn string_escaping() {
-		parse!(r#""Hello, \"world\"!""#);
-		parse!(r#"'Hello \'world\'!'"#);
-		parse!(r#"'\\\\'"#);
-	}
-
-	#[test]
-	fn string_unescaping() {
-		parse!(r#""Hello\nWorld""#);
-	}
-
-	#[test]
-	fn string_verbantim() {
-		parse!(r#"@"Hello\n""World""""#);
-	}
-
-	#[test]
-	fn imports() {
-		parse!("import \"hello\"");
-		parse!("importstr \"garnish.txt\"");
-		parse!("importbin \"garnish.bin\"");
-	}
-
-	#[test]
-	fn empty_object() {
-		parse!("{}");
-	}
-
-	#[test]
-	fn basic_math() {
-		parse!("2+2*2");
-		parse!("2	+ 	  2	  *	2   	");
-		parse!("2+(2+2*2)");
-		parse!("2//comment\n+//comment\n3/*test*/*/*test*/4");
-	}
-
-	#[test]
-	fn suffix() {
-		parse!("std.test");
-		parse!("std(2)");
-		parse!("std.test(2)");
-		parse!("a[b]");
-	}
-
-	#[test]
-	fn array_comp() {
-		parse!("[std.deepJoin(x) for x in arr]");
-	}
-
-	#[test]
-	fn reserved() {
-		parse!("null");
-		parse!("nulla");
-	}
-
-	#[test]
-	fn multiple_args_buf() {
-		parse!("a(b, null_fields)");
-	}
-
-	#[test]
-	fn infix_precedence() {
-		parse!("!a && !b");
-		parse!("!a / !b");
-	}
-
-	#[test]
-	fn double_negation() {
-		parse!("!!a");
-	}
-
-	#[test]
-	fn array_test_error() {
-		parse!("[a for a in b if c for e in f]");
-	}
-
-	#[test]
-	fn missing_newline_between_comment_and_eof() {
-		parse!(
-			"{a:1}
-
-			//+213"
-		);
-	}
-
-	#[test]
-	fn default_param_before_nondefault() {
-		parse!("local x(foo = 'foo', bar) = null; null");
-	}
-
-	#[test]
-	fn add_location_info_to_all_sub_expressions() {
-		parse!("{} { local x = 1, x: x } + {}");
-	}
-}

no changes

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__add_location_info_to_all_sub_expressions.snap
+++ /dev/null
@@ -1,57 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"{} { local x = 1, x: x } + {}\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: ObjExtend(
-            Obj(
-                MemberList(
-                    ObjMembers {
-                        locals: [],
-                        asserts: [],
-                        fields: [],
-                    },
-                ),
-            ) from virtual:<test>:0-2,
-            MemberList(
-                ObjMembers {
-                    locals: [
-                        Field {
-                            into: Full(
-                                "x",
-                            ),
-                            value: Num(
-                                1.0,
-                            ) from virtual:<test>:15-16,
-                        },
-                    ],
-                    asserts: [],
-                    fields: [
-                        FieldMember {
-                            name: Fixed(
-                                "x",
-                            ),
-                            plus: false,
-                            params: None,
-                            visibility: Normal,
-                            value: Var(
-                                "x",
-                            ) from virtual:<test>:21-22,
-                        },
-                    ],
-                },
-            ),
-        ) from virtual:<test>:0-24,
-        op: Add,
-        rhs: Obj(
-            MemberList(
-                ObjMembers {
-                    locals: [],
-                    asserts: [],
-                    fields: [],
-                },
-            ),
-        ) from virtual:<test>:27-29,
-    },
-) from virtual:<test>:0-29

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__array_comp.snap
+++ /dev/null
@@ -1,41 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"[std.deepJoin(x) for x in arr]\")"
----
-ArrComp(
-    Apply(
-        Index {
-            indexable: Var(
-                "std",
-            ) from virtual:<test>:1-4,
-            parts: [
-                IndexPart {
-                    value: Str(
-                        "deepJoin",
-                    ) from virtual:<test>:5-13,
-                },
-            ],
-        } from virtual:<test>:1-13,
-        ArgsDesc {
-            unnamed: [
-                Var(
-                    "x",
-                ) from virtual:<test>:14-15,
-            ],
-            named: [],
-        },
-        false,
-    ) from virtual:<test>:1-16,
-    [
-        ForSpec(
-            ForSpecData(
-                Full(
-                    "x",
-                ),
-                Var(
-                    "arr",
-                ) from virtual:<test>:26-29,
-            ),
-        ),
-    ],
-) from virtual:<test>:0-30

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__array_test_error.snap
+++ /dev/null
@@ -1,38 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"[a for a in b if c for e in f]\")"
----
-ArrComp(
-    Var(
-        "a",
-    ) from virtual:<test>:1-2,
-    [
-        ForSpec(
-            ForSpecData(
-                Full(
-                    "a",
-                ),
-                Var(
-                    "b",
-                ) from virtual:<test>:12-13,
-            ),
-        ),
-        IfSpec(
-            IfSpecData(
-                Var(
-                    "c",
-                ) from virtual:<test>:17-18,
-            ),
-        ),
-        ForSpec(
-            ForSpecData(
-                Full(
-                    "e",
-                ),
-                Var(
-                    "f",
-                ) from virtual:<test>:28-29,
-            ),
-        ),
-    ],
-) from virtual:<test>:0-30

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__basic_math-2.snap
+++ /dev/null
@@ -1,23 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"2\t+ \t  2\t  *\t2   \t\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: Num(
-            2.0,
-        ) from virtual:<test>:0-1,
-        op: Add,
-        rhs: BinaryOp(
-            BinaryOp {
-                lhs: Num(
-                    2.0,
-                ) from virtual:<test>:7-8,
-                op: Mul,
-                rhs: Num(
-                    2.0,
-                ) from virtual:<test>:13-14,
-            },
-        ) from virtual:<test>:7-14,
-    },
-) from virtual:<test>:0-14

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__basic_math-3.snap
+++ /dev/null
@@ -1,31 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"2+(2+2*2)\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: Num(
-            2.0,
-        ) from virtual:<test>:0-1,
-        op: Add,
-        rhs: BinaryOp(
-            BinaryOp {
-                lhs: Num(
-                    2.0,
-                ) from virtual:<test>:3-4,
-                op: Add,
-                rhs: BinaryOp(
-                    BinaryOp {
-                        lhs: Num(
-                            2.0,
-                        ) from virtual:<test>:5-6,
-                        op: Mul,
-                        rhs: Num(
-                            2.0,
-                        ) from virtual:<test>:7-8,
-                    },
-                ) from virtual:<test>:5-8,
-            },
-        ) from virtual:<test>:3-8,
-    },
-) from virtual:<test>:0-9

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__basic_math-4.snap
+++ /dev/null
@@ -1,23 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"2//comment\\n+//comment\\n3/*test*/*/*test*/4\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: Num(
-            2.0,
-        ) from virtual:<test>:0-1,
-        op: Add,
-        rhs: BinaryOp(
-            BinaryOp {
-                lhs: Num(
-                    3.0,
-                ) from virtual:<test>:22-23,
-                op: Mul,
-                rhs: Num(
-                    4.0,
-                ) from virtual:<test>:40-41,
-            },
-        ) from virtual:<test>:22-41,
-    },
-) from virtual:<test>:0-41

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__basic_math.snap
+++ /dev/null
@@ -1,23 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"2+2*2\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: Num(
-            2.0,
-        ) from virtual:<test>:0-1,
-        op: Add,
-        rhs: BinaryOp(
-            BinaryOp {
-                lhs: Num(
-                    2.0,
-                ) from virtual:<test>:2-3,
-                op: Mul,
-                rhs: Num(
-                    2.0,
-                ) from virtual:<test>:4-5,
-            },
-        ) from virtual:<test>:2-5,
-    },
-) from virtual:<test>:0-5

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__default_param_before_nondefault.snap
+++ /dev/null
@@ -1,54 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"local x(foo = 'foo', bar) = null; null\")"
----
-LocalExpr(
-    [
-        Function {
-            name: "x",
-            params: ExprParams {
-                exprs: [
-                    ExprParam {
-                        destruct: Full(
-                            "foo",
-                        ),
-                        default: Some(
-                            Str(
-                                "foo",
-                            ) from virtual:<test>:14-19,
-                        ),
-                    },
-                    ExprParam {
-                        destruct: Full(
-                            "bar",
-                        ),
-                        default: None,
-                    },
-                ],
-                signature: FunctionSignature(
-                    [
-                        ParamParse {
-                            name: Named(
-                                "foo",
-                            ),
-                            default: Exists,
-                        },
-                        ParamParse {
-                            name: Named(
-                                "bar",
-                            ),
-                            default: None,
-                        },
-                    ],
-                ),
-                binds_len: 2,
-            },
-            value: Literal(
-                Null,
-            ) from virtual:<test>:28-32,
-        },
-    ],
-    Literal(
-        Null,
-    ) from virtual:<test>:34-38,
-) from virtual:<test>:0-38

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__double_negation.snap
+++ /dev/null
@@ -1,13 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"!!a\")"
----
-UnaryOp(
-    Not,
-    UnaryOp(
-        Not,
-        Var(
-            "a",
-        ) from virtual:<test>:2-3,
-    ) from virtual:<test>:1-3,
-) from virtual:<test>:0-3

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__empty_object.snap
+++ /dev/null
@@ -1,13 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"{}\")"
----
-Obj(
-    MemberList(
-        ObjMembers {
-            locals: [],
-            asserts: [],
-            fields: [],
-        },
-    ),
-) from virtual:<test>:0-2

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__imports-2.snap
+++ /dev/null
@@ -1,10 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"importstr \\\"garnish.txt\\\"\")"
----
-Import(
-    Str,
-    Str(
-        "garnish.txt",
-    ) from virtual:<test>:10-23,
-) from virtual:<test>:0-23

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__imports-3.snap
+++ /dev/null
@@ -1,10 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"importbin \\\"garnish.bin\\\"\")"
----
-Import(
-    Bin,
-    Str(
-        "garnish.bin",
-    ) from virtual:<test>:10-23,
-) from virtual:<test>:0-23

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__imports.snap
+++ /dev/null
@@ -1,10 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"import \\\"hello\\\"\")"
----
-Import(
-    Normal,
-    Str(
-        "hello",
-    ) from virtual:<test>:7-14,
-) from virtual:<test>:0-14

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__infix_precedence-2.snap
+++ /dev/null
@@ -1,21 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"!a / !b\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: UnaryOp(
-            Not,
-            Var(
-                "a",
-            ) from virtual:<test>:1-2,
-        ) from virtual:<test>:0-2,
-        op: Div,
-        rhs: UnaryOp(
-            Not,
-            Var(
-                "b",
-            ) from virtual:<test>:6-7,
-        ) from virtual:<test>:5-7,
-    },
-) from virtual:<test>:0-7

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__infix_precedence.snap
+++ /dev/null
@@ -1,21 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"!a && !b\")"
----
-BinaryOp(
-    BinaryOp {
-        lhs: UnaryOp(
-            Not,
-            Var(
-                "a",
-            ) from virtual:<test>:1-2,
-        ) from virtual:<test>:0-2,
-        op: And,
-        rhs: UnaryOp(
-            Not,
-            Var(
-                "b",
-            ) from virtual:<test>:7-8,
-        ) from virtual:<test>:6-8,
-    },
-) from virtual:<test>:0-8

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__missing_newline_between_comment_and_eof.snap
+++ /dev/null
@@ -1,25 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"{a:1}\n\n\t\t\t//+213\")"
----
-Obj(
-    MemberList(
-        ObjMembers {
-            locals: [],
-            asserts: [],
-            fields: [
-                FieldMember {
-                    name: Fixed(
-                        "a",
-                    ),
-                    plus: false,
-                    params: None,
-                    visibility: Normal,
-                    value: Num(
-                        1.0,
-                    ) from virtual:<test>:3-4,
-                },
-            ],
-        },
-    ),
-) from virtual:<test>:0-5

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__multiline_string-2.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"|||\\n  Hello world!\\n   a\\n|||\")"
----
-Str(
-    "Hello world!\n a\n",
-) from virtual:<test>:0-27

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__multiline_string-3.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"|||\\n\\t\\tHello world!\\n\\t\\t\\ta\\n|||\")"
----
-Str(
-    "Hello world!\n\ta\n",
-) from virtual:<test>:0-27

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__multiline_string-4.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"|||\\n   Hello world!\\n    a\\n |||\")"
----
-Str(
-    "Hello world!\n a\n",
-) from virtual:<test>:0-30

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__multiline_string.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"|||\\n    Hello world!\\n     a\\n|||\")"
----
-Str(
-    "Hello world!\n a\n",
-) from virtual:<test>:0-31

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__multiple_args_buf.snap
+++ /dev/null
@@ -1,21 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a(b, null_fields)\")"
----
-Apply(
-    Var(
-        "a",
-    ) from virtual:<test>:0-1,
-    ArgsDesc {
-        unnamed: [
-            Var(
-                "b",
-            ) from virtual:<test>:2-3,
-            Var(
-                "null_fields",
-            ) from virtual:<test>:5-16,
-        ],
-        named: [],
-    },
-    false,
-) from virtual:<test>:0-17

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__reserved-2.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"nulla\")"
----
-Var(
-    "nulla",
-) from virtual:<test>:0-5

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__reserved.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"null\")"
----
-Literal(
-    Null,
-) from virtual:<test>:0-4

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__slice-2.snap
+++ /dev/null
@@ -1,20 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a[1::]\")"
----
-Slice(
-    Slice {
-        value: Var(
-            "a",
-        ) from virtual:<test>:0-1,
-        slice: SliceDesc {
-            start: Some(
-                Num(
-                    1.0,
-                ) from virtual:<test>:2-3,
-            ),
-            end: None,
-            step: None,
-        },
-    },
-) from virtual:<test>:0-6

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__slice-3.snap
+++ /dev/null
@@ -1,20 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a[:1:]\")"
----
-Slice(
-    Slice {
-        value: Var(
-            "a",
-        ) from virtual:<test>:0-1,
-        slice: SliceDesc {
-            start: None,
-            end: Some(
-                Num(
-                    1.0,
-                ) from virtual:<test>:3-4,
-            ),
-            step: None,
-        },
-    },
-) from virtual:<test>:0-6

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__slice-4.snap
+++ /dev/null
@@ -1,20 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a[::1]\")"
----
-Slice(
-    Slice {
-        value: Var(
-            "a",
-        ) from virtual:<test>:0-1,
-        slice: SliceDesc {
-            start: None,
-            end: None,
-            step: Some(
-                Num(
-                    1.0,
-                ) from virtual:<test>:4-5,
-            ),
-        },
-    },
-) from virtual:<test>:0-6

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__slice-5.snap
+++ /dev/null
@@ -1,28 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"str[:len - 1]\")"
----
-Slice(
-    Slice {
-        value: Var(
-            "str",
-        ) from virtual:<test>:0-3,
-        slice: SliceDesc {
-            start: None,
-            end: Some(
-                BinaryOp(
-                    BinaryOp {
-                        lhs: Var(
-                            "len",
-                        ) from virtual:<test>:5-8,
-                        op: Sub,
-                        rhs: Num(
-                            1.0,
-                        ) from virtual:<test>:11-12,
-                    },
-                ) from virtual:<test>:5-12,
-            ),
-            step: None,
-        },
-    },
-) from virtual:<test>:0-13

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__slice.snap
+++ /dev/null
@@ -1,20 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a[1:]\")"
----
-Slice(
-    Slice {
-        value: Var(
-            "a",
-        ) from virtual:<test>:0-1,
-        slice: SliceDesc {
-            start: Some(
-                Num(
-                    1.0,
-                ) from virtual:<test>:2-3,
-            ),
-            end: None,
-            step: None,
-        },
-    },
-) from virtual:<test>:0-5

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__string_escaping-2.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(r#\"'Hello \\'world\\'!'\"#)"
----
-Str(
-    "Hello 'world'!",
-) from virtual:<test>:0-18

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__string_escaping-3.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(r#\"'\\\\\\\\'\"#)"
----
-Str(
-    "\\\\",
-) from virtual:<test>:0-6

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__string_escaping.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(r#\"\"Hello, \\\"world\\\"!\"\"#)"
----
-Str(
-    "Hello, \"world\"!",
-) from virtual:<test>:0-19

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__string_unescaping.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(r#\"\"Hello\\nWorld\"\"#)"
----
-Str(
-    "Hello\nWorld",
-) from virtual:<test>:0-14

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__string_verbantim.snap
+++ /dev/null
@@ -1,7 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(r#\"@\"Hello\\n\"\"World\"\"\"\"#)"
----
-Str(
-    "Hello\\n\"World\"",
-) from virtual:<test>:0-19

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__suffix-2.snap
+++ /dev/null
@@ -1,18 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"std(2)\")"
----
-Apply(
-    Var(
-        "std",
-    ) from virtual:<test>:0-3,
-    ArgsDesc {
-        unnamed: [
-            Num(
-                2.0,
-            ) from virtual:<test>:4-5,
-        ],
-        named: [],
-    },
-    false,
-) from virtual:<test>:0-6

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__suffix-3.snap
+++ /dev/null
@@ -1,27 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"std.test(2)\")"
----
-Apply(
-    Index {
-        indexable: Var(
-            "std",
-        ) from virtual:<test>:0-3,
-        parts: [
-            IndexPart {
-                value: Str(
-                    "test",
-                ) from virtual:<test>:4-8,
-            },
-        ],
-    } from virtual:<test>:0-8,
-    ArgsDesc {
-        unnamed: [
-            Num(
-                2.0,
-            ) from virtual:<test>:9-10,
-        ],
-        named: [],
-    },
-    false,
-) from virtual:<test>:0-11

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__suffix-4.snap
+++ /dev/null
@@ -1,16 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"a[b]\")"
----
-Index {
-    indexable: Var(
-        "a",
-    ) from virtual:<test>:0-1,
-    parts: [
-        IndexPart {
-            value: Var(
-                "b",
-            ) from virtual:<test>:2-3,
-        },
-    ],
-} from virtual:<test>:0-4

--- a/crates/jrsonnet-parser/src/snapshots/jrsonnet_parser__tests__suffix.snap
+++ /dev/null
@@ -1,16 +0,0 @@
----
-source: crates/jrsonnet-parser/src/lib.rs
-expression: "parsep(\"std.test\")"
----
-Index {
-    indexable: Var(
-        "std",
-    ) from virtual:<test>:0-3,
-    parts: [
-        IndexPart {
-            value: Str(
-                "test",
-            ) from virtual:<test>:4-8,
-        },
-    ],
-} from virtual:<test>:0-8

--- a/crates/jrsonnet-parser/src/source.rs
+++ /dev/null
@@ -1,307 +0,0 @@
-use std::{
-	any::Any,
-	fmt::{self, Debug, Display},
-	hash::{Hash, Hasher},
-	path::{Path, PathBuf},
-	rc::Rc,
-};
-
-use jrsonnet_gcmodule::Acyclic;
-use jrsonnet_interner::{IBytes, IStr};
-
-use crate::location::{location_to_offset, offset_to_location, CodeLocation};
-
-macro_rules! any_ext_methods {
-	($T:ident) => {
-		fn as_any(&self) -> &dyn Any;
-		fn dyn_hash(&self, hasher: &mut dyn Hasher);
-		fn dyn_eq(&self, other: &dyn $T) -> bool;
-		fn dyn_debug(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result;
-	};
-}
-macro_rules! any_ext_impl {
-	($T:ident) => {
-		fn as_any(&self) -> &dyn Any {
-			self
-		}
-		fn dyn_hash(&self, mut hasher: &mut dyn Hasher) {
-			self.hash(&mut hasher)
-		}
-		fn dyn_eq(&self, other: &dyn $T) -> bool {
-			let Some(other) = other.as_any().downcast_ref::<Self>() else {
-				return false;
-			};
-			let this = <Self as $T>::as_any(self)
-				.downcast_ref::<Self>()
-				.expect("restricted by impl");
-			this == other
-		}
-		fn dyn_debug(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-			<Self as std::fmt::Debug>::fmt(self, fmt)
-		}
-	};
-}
-macro_rules! any_ext {
-	($T:ident) => {
-		impl Hash for dyn $T {
-			fn hash<H: Hasher>(&self, state: &mut H) {
-				self.dyn_hash(state)
-			}
-		}
-		impl PartialEq for dyn $T {
-			fn eq(&self, other: &Self) -> bool {
-				self.dyn_eq(other)
-			}
-		}
-		impl Eq for dyn $T {}
-	};
-}
-pub trait SourcePathT: Acyclic + Debug + Display {
-	/// This method should be checked by resolver before panicking with bad SourcePath input
-	/// if `true` - then resolver may threat this path as default, and default is usally a CWD
-	fn is_default(&self) -> bool;
-	fn path(&self) -> Option<&Path>;
-	any_ext_methods!(SourcePathT);
-}
-any_ext!(SourcePathT);
-
-/// Represents location of a file
-///
-/// Standard CLI only operates using
-/// - [`SourceFile`] - for any file
-/// - [`SourceDirectory`] - for resolution from CWD
-/// - [`SourceVirtual`] - for stdlib/ext-str
-/// - [`SourceFifo`] - for /dev/fd/X (This path may appear with `jrsonnet <(command_that_produces_jsonnet)`)
-///
-/// From all of those, only [`SourceVirtual`] may be constructed manually, any other path kind should be only obtained
-/// from assigned `ImportResolver`
-/// However, you should always check `is_default` method return, as it will return true for any paths, where default
-/// search location is applicable
-///
-/// Resolver may also return custom implementations of this trait, for example it may return http url in case of remotely loaded files
-#[derive(Eq, Clone, Acyclic)]
-pub struct SourcePath(Rc<dyn SourcePathT>);
-impl SourcePath {
-	pub fn new(inner: impl SourcePathT) -> Self {
-		Self(Rc::new(inner))
-	}
-	pub fn downcast_ref<T: SourcePathT>(&self) -> Option<&T> {
-		self.0.as_any().downcast_ref()
-	}
-	pub fn is_default(&self) -> bool {
-		self.0.is_default()
-	}
-	pub fn path(&self) -> Option<&Path> {
-		self.0.path()
-	}
-}
-impl Hash for SourcePath {
-	fn hash<H: Hasher>(&self, state: &mut H) {
-		self.0.hash(state);
-	}
-}
-impl PartialEq for SourcePath {
-	#[allow(clippy::op_ref)]
-	fn eq(&self, other: &Self) -> bool {
-		&*self.0 == &*other.0
-	}
-}
-impl Display for SourcePath {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}", self.0)
-	}
-}
-impl Debug for SourcePath {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{:?}", self.0)
-	}
-}
-impl Default for SourcePath {
-	fn default() -> Self {
-		Self(Rc::new(SourceDefault))
-	}
-}
-
-#[derive(Acyclic, Hash, PartialEq, Eq, Debug)]
-struct SourceDefault;
-impl Display for SourceDefault {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "<default>")
-	}
-}
-impl SourcePathT for SourceDefault {
-	fn is_default(&self) -> bool {
-		true
-	}
-	fn path(&self) -> Option<&Path> {
-		None
-	}
-	any_ext_impl!(SourcePathT);
-}
-
-#[derive(Acyclic, Hash, PartialEq, Eq, Debug)]
-pub struct SourceDefaultIgnoreJpath;
-impl Display for SourceDefaultIgnoreJpath {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "<default (ignoring jpath)>")
-	}
-}
-impl SourcePathT for SourceDefaultIgnoreJpath {
-	fn is_default(&self) -> bool {
-		true
-	}
-	fn path(&self) -> Option<&Path> {
-		None
-	}
-	any_ext_impl!(SourcePathT);
-}
-
-/// Represents path to the file on the disk
-/// Directories shouldn't be put here, as resolution for files differs from resolution for directories:
-///
-/// When `file` is being resolved from `SourceFile(a/b/c)`, it should be resolved to `SourceFile(a/b/file)`,
-/// however if it is being resolved from `SourceDirectory(a/b/c)`, then it should be resolved to `SourceDirectory(a/b/c/file)`
-#[derive(Acyclic, Hash, PartialEq, Eq, Debug)]
-pub struct SourceFile(PathBuf);
-impl SourceFile {
-	pub fn new(path: PathBuf) -> Self {
-		Self(path)
-	}
-	pub fn path(&self) -> &Path {
-		&self.0
-	}
-}
-impl Display for SourceFile {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}", self.0.display())
-	}
-}
-impl SourcePathT for SourceFile {
-	fn is_default(&self) -> bool {
-		false
-	}
-	fn path(&self) -> Option<&Path> {
-		Some(&self.0)
-	}
-	any_ext_impl!(SourcePathT);
-}
-
-/// Represents path to the directory on the disk
-///
-/// See also [`SourceFile`]
-#[derive(Acyclic, Hash, PartialEq, Eq, Debug)]
-pub struct SourceDirectory(PathBuf);
-impl SourceDirectory {
-	pub fn new(path: PathBuf) -> Self {
-		Self(path)
-	}
-	pub fn path(&self) -> &Path {
-		&self.0
-	}
-}
-impl Display for SourceDirectory {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{}", self.0.display())
-	}
-}
-impl SourcePathT for SourceDirectory {
-	fn is_default(&self) -> bool {
-		false
-	}
-	fn path(&self) -> Option<&Path> {
-		Some(&self.0)
-	}
-	any_ext_impl!(SourcePathT);
-}
-
-/// Represents virtual file, whose are located in memory, and shouldn't be cached
-///
-/// It is used for --ext-code=.../--tla-code=.../standard library source code by default,
-/// and user can construct arbitrary values by hand, without asking import resolver
-#[derive(Acyclic, Hash, PartialEq, Eq, Clone)]
-pub struct SourceVirtual(pub IStr);
-impl Display for SourceVirtual {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "virtual:{}", self.0)
-	}
-}
-impl fmt::Debug for SourceVirtual {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "virtual:{}", self.0)
-	}
-}
-impl SourcePathT for SourceVirtual {
-	fn is_default(&self) -> bool {
-		true
-	}
-	fn path(&self) -> Option<&Path> {
-		None
-	}
-	any_ext_impl!(SourcePathT);
-}
-
-/// Represents resolved FIFO file, those files may only be read once, and this type is only used for
-/// unix, where user might want to do `jrsonnet <(command_that_produces_jsonnet_source)`
-/// In most cases, user most probably want to use `jrsonnet -` instead of `jrsonnet /dev/stdin`
-/// for better cross-platform support.
-// PartialEq is limited to ptr equality
-#[allow(clippy::derived_hash_with_manual_eq)]
-#[derive(Acyclic, Debug, Hash)]
-pub struct SourceFifo(pub String, pub IBytes);
-impl PartialEq for SourceFifo {
-	fn eq(&self, other: &Self) -> bool {
-		std::ptr::eq(self, other)
-	}
-}
-impl fmt::Display for SourceFifo {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "fifo({:?})", self.0)
-	}
-}
-impl SourcePathT for SourceFifo {
-	fn is_default(&self) -> bool {
-		// In case of FD input, user won't expect relative paths to be resolved from /dev/fd/
-		true
-	}
-
-	fn path(&self) -> Option<&Path> {
-		None
-	}
-
-	any_ext_impl!(SourcePathT);
-}
-
-/// Either real file, or virtual
-/// Hash of FileName always have same value as raw Path, to make it possible to use with raw_entry_mut
-#[derive(Clone, PartialEq, Eq, Acyclic)]
-pub struct Source(pub Rc<(SourcePath, IStr)>);
-
-impl Source {
-	pub fn new(path: SourcePath, code: IStr) -> Self {
-		Self(Rc::new((path, code)))
-	}
-
-	pub fn new_virtual(name: IStr, code: IStr) -> Self {
-		Self::new(SourcePath::new(SourceVirtual(name)), code)
-	}
-
-	pub fn code(&self) -> &str {
-		&self.0 .1
-	}
-
-	pub fn source_path(&self) -> &SourcePath {
-		&self.0 .0
-	}
-
-	pub fn map_source_locations<const S: usize>(&self, locs: &[u32; S]) -> [CodeLocation; S] {
-		offset_to_location(&self.0 .1, locs)
-	}
-	pub fn map_from_source_location(&self, line: usize, column: usize) -> Option<usize> {
-		location_to_offset(&self.0 .1, line, column)
-	}
-}
-impl fmt::Debug for Source {
-	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-		write!(f, "{:?}", self.0 .0)
-	}
-}

--- a/crates/jrsonnet-parser/src/unescape.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use std::str::Chars;
-
-fn decode_unicode(chars: &mut Chars) -> Option<u16> {
-	IntoIterator::into_iter([chars.next()?, chars.next()?, chars.next()?, chars.next()?])
-		.map(|c| c.to_digit(16).map(|f| f as u16))
-		.try_fold(0u16, |acc, v| Some((acc << 4) | (v?)))
-}
-
-pub fn unescape(s: &str) -> Option<String> {
-	let mut chars = s.chars();
-	let mut out = String::with_capacity(s.len());
-
-	while let Some(c) = chars.next() {
-		if c != '\\' {
-			out.push(c);
-			continue;
-		}
-		match chars.next()? {
-			c @ ('\\' | '"' | '\'') => out.push(c),
-			'b' => out.push('\u{0008}'),
-			'f' => out.push('\u{000c}'),
-			'n' => out.push('\n'),
-			'r' => out.push('\r'),
-			't' => out.push('\t'),
-			'u' => match decode_unicode(&mut chars)? {
-				// May only be second byte
-				0xDC00..=0xDFFF => return None,
-				// Surrogate pair
-				n1 @ 0xD800..=0xDBFF => {
-					if chars.next() != Some('\\') {
-						return None;
-					}
-					if chars.next() != Some('u') {
-						return None;
-					}
-					let n2 = decode_unicode(&mut chars)?;
-					if !matches!(n2, 0xDC00..=0xDFFF) {
-						return None;
-					}
-					let n = (((n1 - 0xD800) as u32) << 10 | (n2 - 0xDC00) as u32) + 0x1_0000;
-					out.push(char::from_u32(n)?);
-				}
-				n => out.push(char::from_u32(n as u32)?),
-			},
-			'x' => {
-				let c = IntoIterator::into_iter([chars.next()?, chars.next()?])
-					.map(|c| c.to_digit(16))
-					.try_fold(0u32, |acc, v| Some((acc << 8) | (v?)))?;
-				out.push(char::from_u32(c)?)
-			}
-			_ => return None,
-		}
-	}
-	Some(out)
-}