git.delta.rocks / jrsonnet / refs/commits / ab84d0c67d11

672 "hi-doc",672 "hi-doc",
673 "indoc",673 "indoc",
674 "insta",674 "insta",
675 "jrsonnet-lexer",
675 "jrsonnet-rowan-parser",676 "jrsonnet-rowan-parser",
676]677]
677678
715 "static_assertions",716 "static_assertions",
716]717]
718
719[[package]]
720name = "jrsonnet-ir-parser"
721version = "0.5.0-pre97"
722dependencies = [
723 "insta",
724 "jrsonnet-gcmodule",
725 "jrsonnet-ir",
726 "jrsonnet-lexer",
727]
717728
718[[package]]729[[package]]
719name = "jrsonnet-lexer"730name = "jrsonnet-lexer"

14jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre97" }14jrsonnet-evaluator = { path = "./crates/jrsonnet-evaluator", version = "0.5.0-pre97" }
15jrsonnet-macros = { path = "./crates/jrsonnet-macros", version = "0.5.0-pre97" }15jrsonnet-macros = { path = "./crates/jrsonnet-macros", version = "0.5.0-pre97" }
16jrsonnet-ir = { path = "./crates/jrsonnet-ir", version = "0.5.0-pre97" }16jrsonnet-ir = { path = "./crates/jrsonnet-ir", version = "0.5.0-pre97" }
17jrsonnet-ir-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }
17jrsonnet-peg-parser = { path = "./crates/jrsonnet-peg-parser", version = "0.5.0-pre97" }18jrsonnet-peg-parser = { path = "./crates/jrsonnet-peg-parser", version = "0.5.0-pre97" }
18jrsonnet-rowan-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }19jrsonnet-rowan-parser = { path = "./crates/jrsonnet-rowan-parser", version = "0.5.0-pre97" }
19jrsonnet-interner = { path = "./crates/jrsonnet-interner", version = "0.5.0-pre97" }20jrsonnet-interner = { path = "./crates/jrsonnet-interner", version = "0.5.0-pre97" }

77
8use jrsonnet_gcmodule::{cc_dyn, Cc};8use jrsonnet_gcmodule::{cc_dyn, Cc};
9use jrsonnet_interner::IBytes;9use jrsonnet_interner::IBytes;
10use jrsonnet_ir::{Expr, Spanned};10use jrsonnet_ir::Expr;
1111
12use crate::{function::NativeFn, Context, Result, Thunk, Val};12use crate::{function::NativeFn, Context, Result, Thunk, Val};
1313

33
4use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_gcmodule::{Cc, Trace};
5use jrsonnet_interner::{IBytes, IStr};5use jrsonnet_interner::{IBytes, IStr};
6use jrsonnet_ir::{Expr, Spanned};6use jrsonnet_ir::Expr;
77
8use super::ArrValue;8use super::ArrValue;
9use crate::function::NativeFn;9use crate::function::NativeFn;

290}290}
291impl<T: Acyclic> ErrorSource for &Spanned<T> {291impl<T: Acyclic> ErrorSource for &Spanned<T> {
292	fn to_location(self) -> Option<Span> {292	fn to_location(self) -> Option<Span> {
293		Some(self.span())293		Some(self.span.clone())
294	}294	}
295}295}
296impl ErrorSource for &Span {296impl ErrorSource for &Span {

4949
50pub fn evaluate_trivial(expr: &Expr) -> Option<Val> {50pub fn evaluate_trivial(expr: &Expr) -> Option<Val> {
51	fn is_trivial(expr: &Expr) -> bool {51	fn is_trivial(expr: &Expr) -> bool {
52		match &*expr {52		match expr {
53			Expr::Str(_)53			Expr::Str(_)
54			| Expr::Num(_)54			| Expr::Num(_)
55			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,55			| Expr::Literal(LiteralType::False | LiteralType::True | LiteralType::Null) => true,
56			Expr::Arr(a) => a.iter().all(|e| is_trivial(&*e)),56			Expr::Arr(a) => a.iter().all(is_trivial),
57			_ => false,57			_ => false,
58		}58		}
59	}59	}
60	Some(match &*expr {60	Some(match expr {
61		Expr::Str(s) => Val::string(s.clone()),61		Expr::Str(s) => Val::string(s.clone()),
62		Expr::Num(n) => {62		Expr::Num(n) => {
63			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))63			Val::Num(NumValue::new(*n).expect("parser will not allow non-finite values"))
71			}71			}
72			Val::Arr(ArrValue::eager(72			Val::Arr(ArrValue::eager(
73				n.iter()73				n.iter()
74					.map(|e| evaluate_trivial(&*e))74					.map(evaluate_trivial)
75					.map(|e| e.expect("checked trivial"))75					.map(|e| e.expect("checked trivial"))
76					.collect(),76					.collect(),
77			))77			))
89	})))89	})))
90}90}
9191
92pub fn evaluate_field_name(ctx: Context, field_name: &FieldName) -> Result<Option<IStr>> {92pub fn evaluate_field_name(ctx: Context, field_name: &Spanned<FieldName>) -> Result<Option<IStr>> {
93	Ok(match field_name {93	Ok(match &field_name.value {
94		FieldName::Fixed(n) => Some(n.clone()),94		FieldName::Fixed(n) => Some(n.clone()),
95		FieldName::Dyn(expr) => {95		FieldName::Dyn(expr) => in_frame(
96			// FIXME: Span96			CallLocation::new(&field_name.span),
97			|| "evaluating field name".to_string(),
98			|| {
97			let value = evaluate(ctx, expr)?;99				let v = evaluate(ctx, expr)?;
98			if matches!(value, Val::Null) {100				Ok(if matches!(v, Val::Null) {
99				None101					None
100			} else {102				} else {
101				Some(IStr::from_untyped(value)?)103					Some(IStr::from_untyped(v)?)
102			}104				})
103		} //105			},
104		  // 	in_frame(106		)?,
105		  // 	CallLocation::new(&expr.span()),
106		  // 	|| "evaluating field name".to_string(),
107		  // 	|| {
108		  // 	},
109		  // )?,
110	})107	})
111}108}
112109
117) -> Result<()> {114) -> Result<()> {
118	match specs.first() {115	match specs.first() {
119		None => callback(ctx)?,116		None => callback(ctx)?,
120		Some(CompSpec::IfSpec(Spanned(IfSpecData(cond), _))) => {117		Some(CompSpec::IfSpec(IfSpecData { cond, span: _ })) => {
121			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {118			if bool::from_untyped(evaluate(ctx.clone(), cond)?)? {
122				evaluate_comp(ctx, &specs[1..], callback)?;119				evaluate_comp(ctx, &specs[1..], callback)?;
123			}120			}
124		}121		}
125		Some(CompSpec::ForSpec(Spanned(ForSpecData(var, expr), _))) => {122		Some(CompSpec::ForSpec(ForSpecData {
123			destruct: into,
124			over,
125		})) => {
126			match evaluate(ctx.clone(), expr)? {126			match evaluate(ctx.clone(), over)? {
127				Val::Arr(list) => {127				Val::Arr(list) => {
128					for item in list.iter_lazy() {128					for item in list.iter_lazy() {
129						let fctx = Pending::new();129						let fctx = Pending::new();
130						let mut new_bindings = FxHashMap::with_capacity(var.binds_len());130						let mut new_bindings = FxHashMap::with_capacity(into.binds_len());
131						destruct(var, item, fctx.clone(), &mut new_bindings)?;131						destruct(into, item, fctx.clone(), &mut new_bindings)?;
132						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);132						let ctx = ctx.clone().extend_bindings(new_bindings).into_future(fctx);
133133
134						evaluate_comp(ctx, &specs[1..], callback)?;134						evaluate_comp(ctx, &specs[1..], callback)?;
235				.field(name.clone())235				.field(name.clone())
236				.with_add(*plus)236				.with_add(*plus)
237				.with_visibility(*visibility)237				.with_visibility(*visibility)
238				// FIXME238				.with_location(field.name.span.clone())
239				// .with_location(value.span())
240				.bindable(UnboundValue {239				.bindable(UnboundValue {
241					uctx,240					uctx,
242					value: value.clone(),241					value: value.clone(),
361	let value = &assertion.0;360	let value = &assertion.0;
362	let msg = &assertion.1;361	let msg = &assertion.1;
363	let assertion_result = in_frame(362	let assertion_result = in_frame(
364		CallLocation::new(&value.span()),363		CallLocation::new(&value.span),
365		|| "assertion condition".to_owned(),364		|| "assertion condition".to_owned(),
366		|| bool::from_untyped(evaluate(ctx.clone(), value)?),365		|| bool::from_untyped(evaluate(ctx.clone(), value)?),
367	)?;366	)?;
368	if !assertion_result {367	if !assertion_result {
369		in_frame(368		in_frame(
370			CallLocation::new(&value.span()),369			CallLocation::new(&value.span),
371			|| "assertion failure".to_owned(),370			|| "assertion failure".to_owned(),
372			|| {371			|| {
373				if let Some(msg) = msg {372				if let Some(msg) = msg {
389388
390pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {389pub fn evaluate_named(ctx: Context, expr: &Expr, name: IStr) -> Result<Val> {
391	use Expr::*;390	use Expr::*;
392	Ok(match &*expr {391	Ok(match expr {
393		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),392		Function(params, body) => evaluate_method(ctx, name, params.clone(), body.clone()),
394		_ => evaluate(ctx, expr)?,393		_ => evaluate(ctx, expr)?,
395	})394	})
433		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,432		BinaryOp(bin) => evaluate_binary_op_special(ctx, &bin.lhs, bin.op, &bin.rhs)?,
434		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,433		UnaryOp(o, v) => evaluate_unary_op(*o, &evaluate(ctx, v)?)?,
435		Var(name) => in_frame(434		Var(name) => in_frame(
436			CallLocation::new(&name.span()),435			CallLocation::new(&name.span),
437			|| format!("local <{}> access", &**name),436			|| format!("local <{}> access", &**name),
438			|| ctx.binding((**name).clone())?.evaluate(),437			|| ctx.binding((**name).clone())?.evaluate(),
439		)?,438		)?,
595				ctx,
596				value,
597				args,
598				CallLocation::new(&args.span()),
599				*tailstrict,
600			)
601		})?,594		})?,
607			evaluate(ctx, &assert.rest)?600			evaluate(ctx, &assert.rest)?
608		}601		}
609		ErrorStmt(s, e) => in_frame(602		ErrorStmt(s, e) => in_frame(
610			CallLocation::new(&s),603			CallLocation::new(s),
611			|| "error statement".to_owned(),604			|| "error statement".to_owned(),
612			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),605			|| bail!(RuntimeError(evaluate(ctx, e)?.to_string()?,)),
613		)?,606		)?,
614		IfElse(if_else) => {607		IfElse(if_else) => {
615			if608			if in_frame(
616			// FIXME609				CallLocation::new(&if_else.cond.span),
617			//in_frame(610				|| "if condition".to_owned(),
618			// CallLocation::new(&if_else.cond.0.span()),
619			// || "if condition".to_owned(),
620			// ||
621			bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.0)?)?611				|| bool::from_untyped(evaluate(ctx.clone(), &if_else.cond.cond)?),
622			// )?
623			{612			)? {
624				evaluate(ctx, &if_else.cond_then)?613				evaluate(ctx, &if_else.cond_then)?
625			} else {614			} else {
626				match &if_else.cond_else {615				match &if_else.cond_else {
637			) -> Result<Option<T>> {626			) -> Result<Option<T>> {
638				if let Some(value) = expr {627				if let Some(value) = expr {
639					Ok(in_frame(628					Ok(in_frame(
640						CallLocation::new(&value.span()),629						CallLocation::new(&value.span),
641						|| format!("slice {desc}"),630						|| format!("slice {desc}"),
642						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),631						|| <Option<T>>::from_untyped(evaluate(ctx, value)?),
643					)?)632					)?)
659				bail!("computed imports are not supported")648				bail!("computed imports are not supported")
660			};649			};
661			with_state(|s| {650			with_state(|s| {
662				let span = kind.span();651				let span = &kind.span;
663				let resolved_path = s.resolve_from(span.0.source_path(), path)?;652				let resolved_path = s.resolve_from(span.0.source_path(), path)?;
664				Ok(match &**kind {653				Ok(match &**kind {
665					ImportKind::Normal => in_frame(654					ImportKind::Normal => in_frame(
666						CallLocation::new(&span),655						CallLocation::new(span),
667						|| format!("import {:?}", path.clone()),656						|| format!("import {:?}", path.clone()),
668						|| s.import_resolved(resolved_path),657						|| s.import_resolved(resolved_path),
669					)?,658					)?,

1use std::cmp::Ordering;1use std::cmp::Ordering;
22
3use jrsonnet_ir::{BinaryOpType, Expr, Spanned, UnaryOpType};3use jrsonnet_ir::{BinaryOpType, Expr, UnaryOpType};
44
5use crate::{5use crate::{
6	arr::ArrValue,6	arr::ArrValue,

3use educe::Educe;3use educe::Educe;
4use jrsonnet_gcmodule::{Cc, Trace};4use jrsonnet_gcmodule::{Cc, Trace};
5use jrsonnet_interner::IStr;5use jrsonnet_interner::IStr;
6use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span, Spanned};6use jrsonnet_ir::{ArgsDesc, Destruct, Expr, ExprParams, Span};
7pub use jrsonnet_macros::builtin;7pub use jrsonnet_macros::builtin;
88
9use self::{9use self::{

42pub use import::*;42pub use import::*;
43use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};43use jrsonnet_gcmodule::{cc_dyn, Cc, Trace};
44pub use jrsonnet_interner::{IBytes, IStr};44pub use jrsonnet_interner::{IBytes, IStr};
45#[doc(hidden)]
46pub use jrsonnet_macros;
47pub use jrsonnet_ir as parser;45pub use jrsonnet_ir as parser;
48use jrsonnet_ir::{Expr, Source, SourcePath, Spanned};46use jrsonnet_ir::{Expr, Source, SourcePath};
47#[doc(hidden)]
48pub use jrsonnet_macros;
49use jrsonnet_peg_parser::ParserSettings;49use jrsonnet_peg_parser::ParserSettings;
50pub use obj::*;50pub use obj::*;
51pub use rustc_hash;51pub use rustc_hash;

4242
43#[derive(Debug, PartialEq, Acyclic)]43#[derive(Debug, PartialEq, Acyclic)]
44pub struct FieldMember {44pub struct FieldMember {
45	pub name: FieldName,45	pub name: Spanned<FieldName>,
46	pub plus: bool,46	pub plus: bool,
47	pub params: Option<ExprParams>,47	pub params: Option<ExprParams>,
48	pub visibility: Visibility,48	pub visibility: Visibility,
295}295}
296296
297#[derive(Debug, PartialEq, Acyclic)]297#[derive(Debug, PartialEq, Acyclic)]
298pub struct IfSpecData(pub Expr);298pub struct IfSpecData {
299	pub span: Span,
300	pub cond: Expr,
301}
299302
300#[derive(Debug, PartialEq, Acyclic)]303#[derive(Debug, PartialEq, Acyclic)]
301pub struct ForSpecData(pub Destruct, pub Expr);304pub struct ForSpecData {
305	pub destruct: Destruct,
306	pub over: Expr,
307}
302308
303#[derive(Debug, PartialEq, Acyclic)]309#[derive(Debug, PartialEq, Acyclic)]
304pub enum CompSpec {310pub enum CompSpec {
305	IfSpec(Spanned<IfSpecData>),311	IfSpec(IfSpecData),
306	ForSpec(Spanned<ForSpecData>),312	ForSpec(ForSpecData),
307}313}
308314
309#[derive(Debug, PartialEq, Acyclic)]315#[derive(Debug, PartialEq, Acyclic)]
462}468}
463469
464#[derive(Clone, PartialEq, Acyclic)]470#[derive(Clone, PartialEq, Acyclic)]
465pub struct Spanned<T: Acyclic>(pub T, pub Span);471pub struct Spanned<T: Acyclic> {
472	pub value: T,
473	pub span: Span,
474}
466impl<T: Acyclic> Deref for Spanned<T> {475impl<T: Acyclic> Deref for Spanned<T> {
467	type Target = T;476	type Target = T;
468	fn deref(&self) -> &Self::Target {477	fn deref(&self) -> &Self::Target {
469		&self.0478		&self.value
470	}479	}
471}480}
472impl<T: Acyclic> Spanned<T> {481impl<T: Acyclic> Spanned<T> {
473	#[inline]482	#[inline]
474	pub fn new(v: T, s: Span) -> Self {483	pub fn new(value: T, span: Span) -> Self {
475		Self(v, s)484		Self { value, span }
476	}485	}
477	#[inline]
478	pub fn span(&self) -> Span {
479		self.1.clone()
480	}
481}486}
482487
483impl<T: Debug + Acyclic> Debug for Spanned<T> {488impl<T: Debug + Acyclic> Debug for Spanned<T> {
488		} else {493		} else {
489			write!(f, "{:?}", expr)?;494			write!(f, "{:?}", expr)?;
490		}495		}
491		write!(f, " from {:?}", self.span())?;496		write!(f, " from {:?}", self.span)?;
492		Ok(())497		Ok(())
493	}498	}
494}499}

181			/ "::" {Visibility::Hidden}181			/ "::" {Visibility::Hidden}
182			/ ":" {Visibility::Normal}182			/ ":" {Visibility::Normal}
183		pub rule field(s: &ParserSettings) -> FieldMember183		pub rule field(s: &ParserSettings) -> FieldMember
184			= name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {FieldMember{184			= name:spanned(<field_name(s)>, s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {FieldMember{
185				name,185				name,
186				plus: plus.is_some(),186				plus: plus.is_some(),
187				params: None,187				params: None,
188				visibility,188				visibility,
189				value: Rc::new(value),189				value: Rc::new(value),
190			}}190			}}
191			/ name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {FieldMember{191			/ name:spanned(<field_name(s)>, s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {FieldMember{
192				name,192				name,
193				plus: false,193				plus: false,
194				params: Some(params),194				params: Some(params),
239				})239				})
240			}240			}
241		pub rule ifspec(s: &ParserSettings) -> IfSpecData241		pub rule ifspec(s: &ParserSettings) -> IfSpecData
242			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}242			= i:spanned(<keyword("if")>, s) _ cond:expr(s) {IfSpecData { span: i.span, cond }}
243		pub rule forspec(s: &ParserSettings) -> ForSpecData243		pub rule forspec(s: &ParserSettings) -> ForSpecData
244			= keyword("for") _ id:destruct(s) _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}244			= keyword("for") _ destruct:destruct(s) _ keyword("in") _ over:expr(s) { ForSpecData { destruct, over } }
245		rule compspec(s: &ParserSettings) -> CompSpec245		rule compspec(s: &ParserSettings) -> CompSpec
246			= i:spanned(<ifspec(s)>, s) { CompSpec::IfSpec(i) } / f:spanned(<forspec(s)>, s) {CompSpec::ForSpec(f)}246			= i:ifspec(s) { CompSpec::IfSpec(i) } / f:forspec(s) {CompSpec::ForSpec(f)}
247		pub rule compspecs(s: &ParserSettings) -> Vec<CompSpec>247		pub rule compspecs(s: &ParserSettings) -> Vec<CompSpec>
248			= specs:compspec(s) ++ _ {?248			= specs:compspec(s) ++ _ {?
249				if !matches!(specs[0], CompSpec::ForSpec(_)) {249				if !matches!(specs[0], CompSpec::ForSpec(_)) {
319				assert, rest319				assert, rest
320			})) }320			})) }
321321
322			/ err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.1, Box::new(expr)) }322			/ err_kw:spanned(<keyword("error")>, s) _ expr:expr(s) { Expr::ErrorStmt(err_kw.span, Box::new(expr)) }
323323
324		rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>324		rule slice_part(s: &ParserSettings) -> Option<Spanned<Expr>>
325			= _ e:(e:spanned(<expr(s)>, s) _{e})? {e}325			= _ e:(e:spanned(<expr(s)>, s) _{e})? {e}
396			}396			}
397		pub rule index_part(s: &ParserSettings) -> IndexPart397		pub rule index_part(s: &ParserSettings) -> IndexPart
398		= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {398		= n:("?" _ ensure_null_coaelse())? "." _ value:id_loc(s) {IndexPart {
399			span: value.1,399			span: value.span,
400			value: value.0,400			value: value.value,
401			#[cfg(feature = "exp-null-coaelse")]401			#[cfg(feature = "exp-null-coaelse")]
402			null_coaelse: n.is_some(),402			null_coaelse: n.is_some(),
403		}}403		}}
404		/ n:("?" _ "." _ ensure_null_coaelse())? value:spanned(<"[" _ v:expr(s) _ "]" {v}>, s) {IndexPart {404		/ n:("?" _ "." _ ensure_null_coaelse())? value:spanned(<"[" _ v:expr(s) _ "]" {v}>, s) {IndexPart {
405			span: value.1,405			span: value.span,
406			value: value.0,406			value: value.value,
407			#[cfg(feature = "exp-null-coaelse")]407			#[cfg(feature = "exp-null-coaelse")]
408			null_coaelse: n.is_some(),408			null_coaelse: n.is_some(),
409		}}409		}}
423}423}
424424
425#[cfg(test)]425#[cfg(test)]
426pub mod tests {426mod tests {
427	use std::fs;
428
427	use insta::assert_snapshot;429	use insta::{assert_snapshot, glob};
428	use jrsonnet_ir::{IStr, Source};430	use jrsonnet_ir::{IStr, Source};
429431
430	use super::parse;
431	use crate::ParserSettings;432	use crate::{parse, ParserSettings};
432433
434	#[test]
433	fn parsep(s: &str) -> String {435	fn snapshots() {
436		glob!("tests/*.jsonnet", |path| {
437			let input = fs::read_to_string(path).expect("read test file");
434		let v = parse(438			let v = parse(
435			s,439				&input,
436			&ParserSettings {440				&ParserSettings {
437				source: Source::new_virtual("<test>".into(), IStr::empty()),441					source: Source::new_virtual("<test>".into(), IStr::empty()),
438			},442				},
439		)443			)
440		.unwrap();444			.unwrap();
441		format!("{v:#?}")445			let v = format!("{v:#?}");
446			assert_snapshot!(v);
447		});
442	}448	}
443
444	macro_rules! parse {
445		($s:expr) => {
446			assert_snapshot!(parsep($s));
447		};
448	}
449
450	#[test]
451	fn multiline_string() {
452		parse!("|||\n    Hello world!\n     a\n|||");
453		parse!("|||\n  Hello world!\n   a\n|||");
454		parse!("|||\n\t\tHello world!\n\t\t\ta\n|||");
455		parse!("|||\n   Hello world!\n    a\n |||");
456	}
457
458	#[test]
459	fn slice() {
460		parse!("a[1:]");
461		parse!("a[1::]");
462		parse!("a[:1:]");
463		parse!("a[::1]");
464		parse!("str[:len - 1]");
465	}
466
467	#[test]
468	fn string_escaping() {
469		parse!(r#""Hello, \"world\"!""#);
470		parse!(r#"'Hello \'world\'!'"#);
471		parse!(r#"'\\\\'"#);
472	}
473
474	#[test]
475	fn string_unescaping() {
476		parse!(r#""Hello\nWorld""#);
477	}
478
479	#[test]
480	fn string_verbantim() {
481		parse!(r#"@"Hello\n""World""""#);
482	}
483
484	#[test]
485	fn imports() {
486		parse!("import \"hello\"");
487		parse!("importstr \"garnish.txt\"");
488		parse!("importbin \"garnish.bin\"");
489	}
490
491	#[test]
492	fn empty_object() {
493		parse!("{}");
494	}
495
496	#[test]
497	fn basic_math() {
498		parse!("2+2*2");
499		parse!("2	+ 	  2	  *	2   	");
500		parse!("2+(2+2*2)");
501		parse!("2//comment\n+//comment\n3/*test*/*/*test*/4");
502	}
503
504	#[test]
505	fn suffix() {
506		parse!("std.test");
507		parse!("std(2)");
508		parse!("std.test(2)");
509		parse!("a[b]");
510	}
511
512	#[test]
513	fn array_comp() {
514		parse!("[std.deepJoin(x) for x in arr]");
515	}
516
517	#[test]
518	fn reserved() {
519		parse!("null");
520		parse!("nulla");
521	}
522
523	#[test]
524	fn multiple_args_buf() {
525		parse!("a(b, null_fields)");
526	}
527
528	#[test]
529	fn infix_precedence() {
530		parse!("!a && !b");
531		parse!("!a / !b");
532	}
533
534	#[test]
535	fn double_negation() {
536		parse!("!!a");
537	}
538
539	#[test]
540	fn array_test_error() {
541		parse!("[a for a in b if c for e in f]");
542	}
543
544	#[test]
545	fn missing_newline_between_comment_and_eof() {
546		parse!(
547			"{a:1}
548
549			//+213"
550		);
551	}
552
553	#[test]
554	fn default_param_before_nondefault() {
555		parse!("local x(foo = 'foo', bar) = null; null");
556	}
557
558	#[test]
559	fn add_location_info_to_all_sub_expressions() {
560		parse!("{} { local x = 1, x: x } + {}");
561	}
562}449}
563450