git.delta.rocks / jrsonnet / refs/commits / 0374cd028e16

1#![allow(clippy::redundant_closure_call)]23use std::rc::Rc;45use peg::parser;6mod expr;7pub use expr::*;8pub use jrsonnet_interner::IStr;9pub use peg;10mod source;11mod unescape;12pub use source::Source;1314pub struct ParserSettings {15	pub file_name: Source,16}1718macro_rules! expr_bin {19	($a:ident $op:ident $b:ident) => {20		Expr::BinaryOp($a, $op, $b)21	};22}23macro_rules! expr_un {24	($op:ident $a:ident) => {25		Expr::UnaryOp($op, $a)26	};27}2829parser! {30	grammar jsonnet_parser() for str {31		use peg::ParseLiteral;3233		rule eof() = quiet!{![_]} / expected!("<eof>")34		rule eol() = "\n" / eof()3536		/// Standard C-like comments37		rule comment()38			= "//" (!eol()[_])* eol()39			/ "/*" ("\\*/" / "\\\\" / (!("*/")[_]))* "*/"40			/ "#" (!eol()[_])* eol()4142		rule single_whitespace() = quiet!{([' ' | '\r' | '\n' | '\t'] / comment())} / expected!("<whitespace>")43		rule _() = quiet!{([' ' | '\r' | '\n' | '\t']+) / comment()}* / expected!("<whitespace>")4445		/// For comma-delimited elements46		rule comma() = quiet!{_ "," _} / expected!("<comma>")47		rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().next().unwrap()}48		rule digit() -> char = d:$(['0'..='9']) {d.chars().next().unwrap()}49		rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']50		/// Sequence of digits51		rule uint_str() -> &'input str = a:$(digit()+) { a }52		/// Number in scientific notation format53		rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.parse().map_err(|_| "<number>") }} / expected!("<number>")5455		/// Reserved word followed by any non-alphanumberic56		rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()57		rule id() -> IStr = v:$(quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")) { v.into() }5859		rule keyword(id: &'static str) -> ()60			= ##parse_string_literal(id) end_of_ident()6162		pub rule param(s: &ParserSettings) -> expr::Param = name:id() expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name, expr) }63		pub rule params(s: &ParserSettings) -> expr::ParamsDesc64			= params:param(s) ** comma() comma()? { expr::ParamsDesc(Rc::new(params)) }65			/ { expr::ParamsDesc(Rc::new(Vec::new())) }6667		pub rule arg(s: &ParserSettings) -> (Option<IStr>, LocExpr)68			= quiet! { name:(s:id() _ "=" !['='] _ {s})? expr:expr(s) {(name, expr)} }69			/ expected!("<argument>")7071		pub rule args(s: &ParserSettings) -> expr::ArgsDesc72			= args:arg(s)**comma() comma()? {?73				let unnamed_count = args.iter().take_while(|(n, _)| n.is_none()).count();74				let mut unnamed = Vec::with_capacity(unnamed_count);75				let mut named = Vec::with_capacity(args.len() - unnamed_count);76				let mut named_started = false;77				for (name, value) in args {78					if let Some(name) = name {79						named_started = true;80						named.push((name, value));81					} else {82						if named_started {83							return Err("<named argument>")84						}85						unnamed.push(value);86					}87				}88				Ok(expr::ArgsDesc::new(unnamed, named))89			}9091		pub rule destruct_rest() -> expr::DestructRest92			= "..." into:(_ into:id() {into})? {if let Some(into) = into {93				expr::DestructRest::Keep(into)94			} else {expr::DestructRest::Drop}}95		pub rule destruct_array(s: &ParserSettings) -> expr::Destruct96			= "[" _ start:destruct(s)**comma() rest:(97				comma() _ rest:destruct_rest()? end:(98					comma() end:destruct(s)**comma() (_ comma())? {end}99					/ comma()? {Vec::new()}100				) {(rest, end)}101				/ comma()? {(None, Vec::new())}102			) _ "]" {?103				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Array {104					start,105					rest: rest.0,106					end: rest.1,107				});108				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")109			}110		pub rule destruct_object(s: &ParserSettings) -> expr::Destruct111			= "{" _112				fields:(name:id() _ into:(":" _ into:destruct(s) {into})? {(name, into)})**comma()113				rest:(114					comma() rest:destruct_rest()? {rest}115					/ comma()? {None}116				)117			_ "}" {?118				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Object {119					fields,120					rest,121				});122				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")123			}124		pub rule destruct(s: &ParserSettings) -> expr::Destruct125			= v:id() {expr::Destruct::Full(v)}126			/ "?" {?127				#[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Skip);128				#[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")129			}130			/ arr:destruct_array(s) {arr}131			/ obj:destruct_object(s) {obj}132133		pub rule bind(s: &ParserSettings) -> expr::BindSpec134			= into:destruct(s) _ "=" _ expr:expr(s) {expr::BindSpec::Field{into, value: expr}}135			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec::Function{name, params, value: expr}}136137		pub rule assertion(s: &ParserSettings) -> expr::AssertStmt138			= keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }139140		pub rule whole_line() -> &'input str141			= str:$((!['\n'][_])* "\n") {str}142		pub rule string_block() -> String143			= "|||" (!['\n']single_whitespace())* "\n"144			  empty_lines:$(['\n']*)145			  prefix:[' ' | '\t']+ first_line:whole_line()146			  lines:("\n" {"\n"} / [' ' | '\t']*<{prefix.len()}> s:whole_line() {s})*147			  [' ' | '\t']*<, {prefix.len() - 1}> "|||"148			  {let mut l = empty_lines.to_owned(); l.push_str(first_line); l.extend(lines); l}149150		rule hex_char()151			= quiet! { ['0'..='9' | 'a'..='f' | 'A'..='F'] } / expected!("<hex char>")152153		rule string_char(c: rule<()>)154			= (!['\\']!c()[_])+155			/ "\\\\"156			/ "\\u" hex_char() hex_char() hex_char() hex_char()157			/ "\\x" hex_char() hex_char()158			/ ['\\'] (quiet! { ['b' | 'f' | 'n' | 'r' | 't' | '"' | '\''] } / expected!("<escape character>"))159		pub rule string() -> String160			= ['"'] str:$(string_char(<"\"">)*) ['"'] {? unescape::unescape(str).ok_or("<escaped string>")}161			/ ['\''] str:$(string_char(<"\'">)*) ['\''] {? unescape::unescape(str).ok_or("<escaped string>")}162			/ quiet!{ "@'" str:$(("''" / (!['\''][_]))*) "'" {str.replace("''", "'")}163			/ "@\"" str:$(("\"\"" / (!['"'][_]))*) "\"" {str.replace("\"\"", "\"")}164			/ string_block() } / expected!("<string>")165166		pub rule field_name(s: &ParserSettings) -> expr::FieldName167			= name:id() {expr::FieldName::Fixed(name)}168			/ name:string() {expr::FieldName::Fixed(name.into())}169			/ "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}170		pub rule visibility() -> expr::Visibility171			= ":::" {expr::Visibility::Unhide}172			/ "::" {expr::Visibility::Hidden}173			/ ":" {expr::Visibility::Normal}174		pub rule field(s: &ParserSettings) -> expr::FieldMember175			= name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {expr::FieldMember{176				name,177				plus: plus.is_some(),178				params: None,179				visibility,180				value,181			}}182			/ name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {expr::FieldMember{183				name,184				plus: false,185				params: Some(params),186				visibility,187				value,188			}}189		pub rule obj_local(s: &ParserSettings) -> BindSpec190			= keyword("local") _ bind:bind(s) {bind}191		pub rule member(s: &ParserSettings) -> expr::Member192			= bind:obj_local(s) {expr::Member::BindStmt(bind)}193			/ assertion:assertion(s) {expr::Member::AssertStmt(assertion)}194			/ field:field(s) {expr::Member::Field(field)}195		pub rule objinside(s: &ParserSettings) -> expr::ObjBody196			= pre_locals:(b: obj_local(s) comma() {b})* "[" _ key:expr(s) _ "]" _ plus:"+"? _ ":" _ value:expr(s) post_locals:(comma() b:obj_local(s) {b})* _ forspec:forspec(s) others:(_ rest:compspec(s) {rest})? {197				let mut compspecs = vec![CompSpec::ForSpec(forspec)];198				compspecs.extend(others.unwrap_or_default());199				expr::ObjBody::ObjComp(expr::ObjComp{200					pre_locals,201					key,202					plus: plus.is_some(),203					value,204					post_locals,205					compspecs,206				})207			}208			/ members:(member(s) ** comma()) comma()? {expr::ObjBody::MemberList(members)}209		pub rule ifspec(s: &ParserSettings) -> IfSpecData210			= keyword("if") _ expr:expr(s) {IfSpecData(expr)}211		pub rule forspec(s: &ParserSettings) -> ForSpecData212			= keyword("for") _ id:id() _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}213		pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec>214			= s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} ) ** _ {s}215		pub rule local_expr(s: &ParserSettings) -> Expr216			= keyword("local") _ binds:bind(s) ** comma() _ ";" _ expr:expr(s) { Expr::LocalExpr(binds, expr) }217		pub rule string_expr(s: &ParserSettings) -> Expr218			= s:string() {Expr::Str(s.into())}219		pub rule obj_expr(s: &ParserSettings) -> Expr220			= "{" _ body:objinside(s) _ "}" {Expr::Obj(body)}221		pub rule array_expr(s: &ParserSettings) -> Expr222			= "[" _ elems:(expr(s) ** comma()) _ comma()? "]" {Expr::Arr(elems)}223		pub rule array_comp_expr(s: &ParserSettings) -> Expr224			= "[" _ expr:expr(s) _ comma()? _ forspec:forspec(s) _ others:(others: compspec(s) _ {others})? "]" {225				let mut specs = vec![CompSpec::ForSpec(forspec)];226				specs.extend(others.unwrap_or_default());227				Expr::ArrComp(expr, specs)228			}229		pub rule number_expr(s: &ParserSettings) -> Expr230			= n:number() { expr::Expr::Num(n) }231		pub rule var_expr(s: &ParserSettings) -> Expr232			= n:id() { expr::Expr::Var(n) }233		pub rule id_loc(s: &ParserSettings) -> LocExpr234			= a:position!() n:id() b:position!() { LocExpr(Rc::new(expr::Expr::Str(n)), ExprLocation(s.file_name.clone(), a as u32,b as u32)) }235		pub rule if_then_else_expr(s: &ParserSettings) -> Expr236			= cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse{237				cond,238				cond_then,239				cond_else,240			}}241242		pub rule literal(s: &ParserSettings) -> Expr243			= v:(244				keyword("null") {LiteralType::Null}245				/ keyword("true") {LiteralType::True}246				/ keyword("false") {LiteralType::False}247				/ keyword("self") {LiteralType::This}248				/ keyword("$") {LiteralType::Dollar}249				/ keyword("super") {LiteralType::Super}250			) {Expr::Literal(v)}251252		pub rule expr_basic(s: &ParserSettings) -> Expr253			= literal(s)254255			/ quiet!{"$intrinsicThisFile" {Expr::IntrinsicThisFile}}256			/ quiet!{"$intrinsicId" {Expr::IntrinsicId}}257			/ quiet!{"$intrinsic(" name:id() ")" {Expr::Intrinsic(name)}}258259			/ string_expr(s) / number_expr(s)260			/ array_expr(s)261			/ obj_expr(s)262			/ array_expr(s)263			/ array_comp_expr(s)264265			/ keyword("importstr") _ path:string() {Expr::ImportStr(path.into())}266			/ keyword("importbin") _ path:string() {Expr::ImportBin(path.into())}267			/ keyword("import") _ path:string() {Expr::Import(path.into())}268269			/ var_expr(s)270			/ local_expr(s)271			/ if_then_else_expr(s)272273			/ keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}274			/ assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }275276			/ keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }277278		rule slice_part(s: &ParserSettings) -> Option<LocExpr>279			= _ e:(e:expr(s) _{e})? {e}280		pub rule slice_desc(s: &ParserSettings) -> SliceDesc281			= start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {282				let (end, step) = if let Some((end, step)) = pair {283					(end, step)284				}else{285					(None, None)286				};287288				SliceDesc { start, end, step }289			}290291		rule binop(x: rule<()>) -> ()292			= quiet!{ x() } / expected!("<binary op>")293		rule unaryop(x: rule<()>) -> ()294			= quiet!{ x() } / expected!("<unary op>")295296297		use BinaryOpType::*;298		use UnaryOpType::*;299		rule expr(s: &ParserSettings) -> LocExpr300			= precedence! {301				start:position!() v:@ end:position!() { LocExpr(Rc::new(v), ExprLocation(s.file_name.clone(), start as u32, end as u32)) }302				--303				a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}304				--305				a:(@) _ binop(<"&&">) _ b:@ {expr_bin!(a And b)}306				--307				a:(@) _ binop(<"|">) _ b:@ {expr_bin!(a BitOr b)}308				--309				a:@ _ binop(<"^">) _ b:(@) {expr_bin!(a BitXor b)}310				--311				a:(@) _ binop(<"&">) _ b:@ {expr_bin!(a BitAnd b)}312				--313				a:(@) _ binop(<"==">) _ b:@ {expr_bin!(a Eq b)}314				a:(@) _ binop(<"!=">) _ b:@ {expr_bin!(a Neq b)}315				--316				a:(@) _ binop(<"<">) _ b:@ {expr_bin!(a Lt b)}317				a:(@) _ binop(<">">) _ b:@ {expr_bin!(a Gt b)}318				a:(@) _ binop(<"<=">) _ b:@ {expr_bin!(a Lte b)}319				a:(@) _ binop(<">=">) _ b:@ {expr_bin!(a Gte b)}320				a:(@) _ binop(<keyword("in")>) _ b:@ {expr_bin!(a In b)}321				--322				a:(@) _ binop(<"<<">) _ b:@ {expr_bin!(a Lhs b)}323				a:(@) _ binop(<">>">) _ b:@ {expr_bin!(a Rhs b)}324				--325				a:(@) _ binop(<"+">) _ b:@ {expr_bin!(a Add b)}326				a:(@) _ binop(<"-">) _ b:@ {expr_bin!(a Sub b)}327				--328				a:(@) _ binop(<"*">) _ b:@ {expr_bin!(a Mul b)}329				a:(@) _ binop(<"/">) _ b:@ {expr_bin!(a Div b)}330				a:(@) _ binop(<"%">) _ b:@ {expr_bin!(a Mod b)}331				--332						unaryop(<"-">) _ b:@ {expr_un!(Minus b)}333						unaryop(<"!">) _ b:@ {expr_un!(Not b)}334						unaryop(<"~">) _ b:@ {expr_un!(BitNot b)}335				--336				a:(@) _ "[" _ e:slice_desc(s) _ "]" {Expr::Slice(a, e)}337				a:(@) _ "." _ a:position!() e:id_loc(s) b:position!() {Expr::Index(a, e)}338				a:(@) _ "[" _ e:expr(s) _ "]" {Expr::Index(a, e)}339				a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(a, args, ts.is_some())}340				a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(a, body)}341				--342				e:expr_basic(s) {e}343				"(" _ e:expr(s) _ ")" {Expr::Parened(e)}344			}345346		pub rule jsonnet(s: &ParserSettings) -> LocExpr = _ e:expr(s) _ {e}347	}348}349350pub type ParseError = peg::error::ParseError<peg::str::LineCol>;351pub fn parse(str: &str, settings: &ParserSettings) -> Result<LocExpr, ParseError> {352	jsonnet_parser::jsonnet(str, settings)353}354/// Used for importstr values355pub fn string_to_expr(str: IStr, settings: &ParserSettings) -> LocExpr {356	let len = str.len();357	LocExpr(358		Rc::new(Expr::Str(str)),359		ExprLocation(settings.file_name.clone(), 0, len as u32),360	)361}362363#[cfg(test)]364pub mod tests {365	use std::path::PathBuf;366367	use BinaryOpType::*;368369	use super::{expr::*, parse};370	use crate::{source::Source, ParserSettings};371372	macro_rules! parse {373		($s:expr) => {374			parse(375				$s,376				&ParserSettings {377					file_name: Source::new(PathBuf::from("test.jsonnet")).unwrap(),378				},379			)380			.unwrap()381		};382	}383384	macro_rules! el {385		($expr:expr, $from:expr, $to:expr$(,)?) => {386			LocExpr(387				std::rc::Rc::new($expr),388				ExprLocation(389					Source::new(PathBuf::from("test.jsonnet")).unwrap(),390					$from,391					$to,392				),393			)394		};395	}396397	#[test]398	fn multiline_string() {399		assert_eq!(400			parse!("|||\n    Hello world!\n     a\n|||"),401			el!(Expr::Str("Hello world!\n a\n".into()), 0, 31),402		);403		assert_eq!(404			parse!("|||\n  Hello world!\n   a\n|||"),405			el!(Expr::Str("Hello world!\n a\n".into()), 0, 27),406		);407		assert_eq!(408			parse!("|||\n\t\tHello world!\n\t\t\ta\n|||"),409			el!(Expr::Str("Hello world!\n\ta\n".into()), 0, 27),410		);411		assert_eq!(412			parse!("|||\n   Hello world!\n    a\n |||"),413			el!(Expr::Str("Hello world!\n a\n".into()), 0, 30),414		);415	}416417	#[test]418	fn slice() {419		parse!("a[1:]");420		parse!("a[1::]");421		parse!("a[:1:]");422		parse!("a[::1]");423		parse!("str[:len - 1]");424	}425426	#[test]427	fn string_escaping() {428		assert_eq!(429			parse!(r#""Hello, \"world\"!""#),430			el!(Expr::Str(r#"Hello, "world"!"#.into()), 0, 19),431		);432		assert_eq!(433			parse!(r#"'Hello \'world\'!'"#),434			el!(Expr::Str("Hello 'world'!".into()), 0, 18),435		);436		assert_eq!(parse!(r#"'\\\\'"#), el!(Expr::Str("\\\\".into()), 0, 6));437	}438439	#[test]440	fn string_unescaping() {441		assert_eq!(442			parse!(r#""Hello\nWorld""#),443			el!(Expr::Str("Hello\nWorld".into()), 0, 14),444		);445	}446447	#[test]448	fn string_verbantim() {449		assert_eq!(450			parse!(r#"@"Hello\n""World""""#),451			el!(Expr::Str("Hello\\n\"World\"".into()), 0, 19),452		);453	}454455	#[test]456	fn imports() {457		assert_eq!(458			parse!("import \"hello\""),459			el!(Expr::Import("hello".into()), 0, 14),460		);461		assert_eq!(462			parse!("importstr \"garnish.txt\""),463			el!(Expr::ImportStr("garnish.txt".into()), 0, 23)464		);465		assert_eq!(466			parse!("importbin \"garnish.bin\""),467			el!(Expr::ImportBin("garnish.bin".into()), 0, 23)468		);469	}470471	#[test]472	fn empty_object() {473		assert_eq!(474			parse!("{}"),475			el!(Expr::Obj(ObjBody::MemberList(vec![])), 0, 2)476		);477	}478479	#[test]480	fn basic_math() {481		assert_eq!(482			parse!("2+2*2"),483			el!(484				Expr::BinaryOp(485					el!(Expr::Num(2.0), 0, 1),486					Add,487					el!(488						Expr::BinaryOp(el!(Expr::Num(2.0), 2, 3), Mul, el!(Expr::Num(2.0), 4, 5)),489						2,490						5491					)492				),493				0,494				5495			)496		);497	}498499	#[test]500	fn basic_math_with_indents() {501		assert_eq!(502			parse!("2	+ 	  2	  *	2   	"),503			el!(504				Expr::BinaryOp(505					el!(Expr::Num(2.0), 0, 1),506					Add,507					el!(508						Expr::BinaryOp(el!(Expr::Num(2.0), 7, 8), Mul, el!(Expr::Num(2.0), 13, 14),),509						7,510						14511					),512				),513				0,514				14515			)516		);517	}518519	#[test]520	fn basic_math_parened() {521		assert_eq!(522			parse!("2+(2+2*2)"),523			el!(524				Expr::BinaryOp(525					el!(Expr::Num(2.0), 0, 1),526					Add,527					el!(528						Expr::Parened(el!(529							Expr::BinaryOp(530								el!(Expr::Num(2.0), 3, 4),531								Add,532								el!(533									Expr::BinaryOp(534										el!(Expr::Num(2.0), 5, 6),535										Mul,536										el!(Expr::Num(2.0), 7, 8),537									),538									5,539									8540								),541							),542							3,543							8544						)),545						2,546						9547					),548				),549				0,550				9551			)552		);553	}554555	/// Comments should not affect parsing556	#[test]557	fn comments() {558		assert_eq!(559			parse!("2//comment\n+//comment\n3/*test*/*/*test*/4"),560			el!(561				Expr::BinaryOp(562					el!(Expr::Num(2.0), 0, 1),563					Add,564					el!(565						Expr::BinaryOp(566							el!(Expr::Num(3.0), 22, 23),567							Mul,568							el!(Expr::Num(4.0), 40, 41)569						),570						22,571						41572					)573				),574				0,575				41576			)577		);578	}579580	/// Comments should be able to be escaped581	#[test]582	fn comment_escaping() {583		assert_eq!(584			parse!("2/*\\*/+*/ - 22"),585			el!(586				Expr::BinaryOp(el!(Expr::Num(2.0), 0, 1), Sub, el!(Expr::Num(22.0), 12, 14)),587				0,588				14589			)590		);591	}592593	#[test]594	fn suffix() {595		// assert_eq!(parse!("std.test"), el!(Expr::Num(2.2)));596		// assert_eq!(parse!("std(2)"), el!(Expr::Num(2.2)));597		// assert_eq!(parse!("std.test(2)"), el!(Expr::Num(2.2)));598		// assert_eq!(parse!("a[b]"), el!(Expr::Num(2.2)))599	}600601	#[test]602	fn array_comp() {603		use Expr::*;604		/*605		`ArrComp(Apply(Index(Var("std") from "test.jsonnet":1-4, Var("deepJoin") from "test.jsonnet":5-13) from "test.jsonnet":1-13, ArgsDesc { unnamed: [Var("x") from "test.jsonnet":14-15], named: [] }, false) from "test.jsonnet":1-16, [ForSpec(ForSpecData("x", Var("arr") from "test.jsonnet":26-29))]) from "test.jsonnet":0-30`,606		`ArrComp(Apply(Index(Var("std") from "test.jsonnet":1-4, Str("deepJoin") from "test.jsonnet":5-13) from "test.jsonnet":1-13, ArgsDesc { unnamed: [Var("x") from "test.jsonnet":14-15], named: [] }, false) from "test.jsonnet":1-16, [ForSpec(ForSpecData("x", Var("arr") from "test.jsonnet":26-29))]) from "test.jsonnet":0-30`607				*/608		assert_eq!(609			parse!("[std.deepJoin(x) for x in arr]"),610			el!(611				ArrComp(612					el!(613						Apply(614							el!(615								Index(616									el!(Var("std".into()), 1, 4),617									el!(Str("deepJoin".into()), 5, 13)618								),619								1,620								13621							),622							ArgsDesc::new(vec![el!(Var("x".into()), 14, 15)], vec![]),623							false,624						),625						1,626						16627					),628					vec![CompSpec::ForSpec(ForSpecData(629						"x".into(),630						el!(Var("arr".into()), 26, 29)631					))]632				),633				0,634				30635			),636		)637	}638639	#[test]640	fn reserved() {641		use Expr::*;642		assert_eq!(parse!("null"), el!(Literal(LiteralType::Null), 0, 4));643		assert_eq!(parse!("nulla"), el!(Var("nulla".into()), 0, 5));644	}645646	#[test]647	fn multiple_args_buf() {648		parse!("a(b, null_fields)");649	}650651	#[test]652	fn infix_precedence() {653		use Expr::*;654		assert_eq!(655			parse!("!a && !b"),656			el!(657				BinaryOp(658					el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),659					And,660					el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 7, 8)), 6, 8)661				),662				0,663				8664			)665		);666	}667668	#[test]669	fn infix_precedence_division() {670		use Expr::*;671		assert_eq!(672			parse!("!a / !b"),673			el!(674				BinaryOp(675					el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),676					Div,677					el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 6, 7)), 5, 7)678				),679				0,680				7681			)682		);683	}684685	#[test]686	fn double_negation() {687		use Expr::*;688		assert_eq!(689			parse!("!!a"),690			el!(691				UnaryOp(692					UnaryOpType::Not,693					el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 2, 3)), 1, 3)694				),695				0,696				3697			)698		)699	}700701	#[test]702	fn array_test_error() {703		parse!("[a for a in b if c for e in f]");704		//                    ^^^^ failed code705	}706707	#[test]708	fn missing_newline_between_comment_and_eof() {709		parse!(710			"{a:1}711712			//+213"713		);714	}715716	#[test]717	fn default_param_before_nondefault() {718		parse!("local x(foo = 'foo', bar) = null; null");719	}720721	#[test]722	fn can_parse_stdlib() {723		parse!(jrsonnet_stdlib::STDLIB_STR);724	}725726	#[test]727	fn add_location_info_to_all_sub_expressions() {728		use Expr::*;729730		let file_name = Source::new(PathBuf::from("test.jsonnet")).unwrap();731		let expr = parse(732			"{} { local x = 1, x: x } + {}",733			&ParserSettings {734				file_name: file_name.clone(),735			},736		)737		.unwrap();738		assert_eq!(739			expr,740			el!(741				BinaryOp(742					el!(743						ObjExtend(744							el!(Obj(ObjBody::MemberList(vec![])), 0, 2),745							ObjBody::MemberList(vec![746								Member::BindStmt(BindSpec::Field {747									into: Destruct::Full("x".into()),748									value: el!(Num(1.0), 15, 16)749								}),750								Member::Field(FieldMember {751									name: FieldName::Fixed("x".into()),752									plus: false,753									params: None,754									visibility: Visibility::Normal,755									value: el!(Var("x".into()), 21, 22),756								})757							])758						),759						0,760						24761					),762					BinaryOpType::Add,763					el!(Obj(ObjBody::MemberList(vec![])), 27, 29),764				),765				0,766				29767			),768		);769	}770}