git.delta.rocks / jrsonnet / refs/commits / 4aecc221ffa5

1#![feature(box_syntax)]23use peg::parser;4use std::rc::Rc;5mod expr;6pub use expr::*;78enum Suffix {9	String(String),10	Slice(SliceDesc),11	Expression(LocExpr),12	Apply(expr::ArgsDesc),13	Extend(expr::ObjBody),14}15struct LocSuffix(Suffix, ExprLocation);1617pub struct ParserSettings {18	pub loc_data: bool,19	pub file_name: String,20}2122parser! {23	grammar jsonnet_parser() for str {24		use peg::ParseLiteral;2526		/// Standard C-like comments27		rule comment() = "//" (!['\n'][_])* "\n" / "/*" ((!("*/")[_][_])/("\\" "*/"))* "*/"28		rule _() = ([' ' | '\n' | '\t'] / comment())*2930		/// For comma-delimited elements31		rule comma() = quiet!{_ "," _} / expected!("<comma>")32		rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().next().unwrap()}33		rule digit() -> char = d:$(['0'..='9']) {d.chars().next().unwrap()}34		rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']35		/// Sequence of digits36		rule uint() -> u32 = a:$(digit()+) { a.parse().unwrap() }37		/// Number in scientific notation format38		rule number() -> f64 = quiet!{a:$(uint() ("." uint())? (['e'|'E'] (s:['+'|'-'])? uint())?) { a.parse().unwrap() }} / expected!("<number>")3940		/// Reserved word followed by any non-alphanumberic41		rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()42		rule id() -> String = quiet!{ !reserved() s:$(alpha() (alpha() / digit())*) {s.to_owned()}} / expected!("<identifier>")4344		rule keyword(id: &'static str) = ##parse_string_literal(id) end_of_ident()45		rule l(s: &ParserSettings, x: rule<Expr>) -> LocExpr = start:position!() v:x() end:position!() {loc_expr!(v, s.loc_data, (s.file_name.clone(), start, end))}4647		pub rule param(s: &ParserSettings) -> expr::Param = name:id() expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name, expr) }48		pub rule params(s: &ParserSettings) -> expr::ParamsDesc49			= params:(param(s) ** comma()) {50				let mut defaults_started = false;51				for param in &params {52					defaults_started = defaults_started || param.1.is_some();53					assert_eq!(defaults_started, param.1.is_some(), "defauld parameters should be used after all positionals");54				}55				expr::ParamsDesc(params)56			}57			/ { expr::ParamsDesc(Vec::new()) }5859		pub rule arg(s: &ParserSettings) -> expr::Arg60			= name:id() _ "=" _ expr:expr(s) {expr::Arg(Some(name), expr)}61			/ expr:expr(s) {expr::Arg(None, expr)}62		pub rule args(s: &ParserSettings) -> expr::ArgsDesc63			= args:arg(s) ** comma() comma()? {64				let mut named_started = false;65				for arg in &args {66					named_started = named_started || arg.0.is_some();67					assert_eq!(named_started, arg.0.is_some(), "named args should be used after all positionals");68				}69				expr::ArgsDesc(args)70			}71			/ { expr::ArgsDesc(Vec::new()) }7273		pub rule bind(s: &ParserSettings) -> expr::BindSpec74			= name:id() _ "=" _ expr:expr(s) {expr::BindSpec{name, params: None, value: expr}}75			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec{name, params: Some(params), value: expr}}76		pub rule assertion(s: &ParserSettings) -> expr::AssertStmt = keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }77		pub rule string() -> String78			= "\"" str:$(("\\\"" / !['"'][_])*) "\"" {str.to_owned()}79			/ "'" str:$((!['\''][_])*) "'" {str.to_owned()}80		pub rule field_name(s: &ParserSettings) -> expr::FieldName81			= name:id() {expr::FieldName::Fixed(name)}82			/ name:string() {expr::FieldName::Fixed(name)}83			/ "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}84		pub rule visibility() -> expr::Visibility85			= ":::" {expr::Visibility::Unhide}86			/ "::" {expr::Visibility::Hidden}87			/ ":" {expr::Visibility::Normal}88		pub rule field(s: &ParserSettings) -> expr::FieldMember89			= name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {expr::FieldMember{90				name,91				plus: plus.is_some(),92				params: None,93				visibility,94				value,95			}}96			/ name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {expr::FieldMember{97				name,98				plus: false,99				params: Some(params),100				visibility,101				value,102			}}103		pub rule obj_local(s: &ParserSettings) -> BindSpec104			= keyword("local") _ bind:bind(s) {bind}105		pub rule member(s: &ParserSettings) -> expr::Member106			= bind:obj_local(s) {expr::Member::BindStmt(bind)}107			/ assertion:assertion(s) {expr::Member::AssertStmt(assertion)}108			/ field:field(s) {expr::Member::Field(field)}109		pub rule objinside(s: &ParserSettings) -> expr::ObjBody110			= pre_locals:(b: obj_local(s) comma() {b})* "[" _ key:expr(s) _ "]" _ ":" _ value:expr(s) post_locals:(comma() b:obj_local(s) {b})* _ first:forspec(s) rest:(_ rest:compspec(s) {rest})? {111				expr::ObjBody::ObjComp {112					pre_locals,113					key,114					value,115					post_locals,116					first,117					rest: rest.unwrap_or_default(),118				}119			}120			/ members:(member(s) ** comma()) comma()? {expr::ObjBody::MemberList(members)}121		pub rule ifspec(s: &ParserSettings) -> IfSpecData = keyword("if") _ expr:expr(s) {IfSpecData(expr)}122		pub rule forspec(s: &ParserSettings) -> ForSpecData = keyword("for") _ id:id() _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}123		pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec> = s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} )+ {s}124		pub rule local_expr(s: &ParserSettings) -> LocExpr = l(s,<keyword("local") _ binds:bind(s) ** comma() _ ";" _ expr:expr(s) { Expr::LocalExpr(binds, expr) }>)125		pub rule string_expr(s: &ParserSettings) -> LocExpr = l(s, <s:string() {Expr::Str(s)}>)126		pub rule obj_expr(s: &ParserSettings) -> LocExpr = l(s,<"{" _ body:objinside(s) _ "}" {Expr::Obj(body)}>)127		pub rule array_expr(s: &ParserSettings) -> LocExpr = l(s,<"[" _ elems:(expr(s) ** comma()) _ comma()? "]" {Expr::Arr(elems)}>)128		pub rule array_comp_expr(s: &ParserSettings) -> LocExpr = l(s,<"[" _ expr:expr(s) _ comma()? _ forspec:forspec(s) _ others:(others: compspec(s) _ {others})? "]" {Expr::ArrComp(expr, [vec![CompSpec::ForSpec(forspec)], others.unwrap_or_default()].concat())}>)129		pub rule number_expr(s: &ParserSettings) -> LocExpr = l(s,<n:number() { expr::Expr::Num(n) }>)130		pub rule var_expr(s: &ParserSettings) -> LocExpr = l(s,<n:id() { expr::Expr::Var(n) }>)131		pub rule if_then_else_expr(s: &ParserSettings) -> LocExpr = l(s,<cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse{132			cond,133			cond_then,134			cond_else,135		}}>)136137		pub rule literal(s: &ParserSettings) -> LocExpr138			= l(s,<v:(139				keyword("null") {LiteralType::Null}140				/ keyword("true") {LiteralType::True}141				/ keyword("false") {LiteralType::False}142				/ keyword("self") {LiteralType::This}143				/ keyword("$") {LiteralType::Dollar}144				/ keyword("super") {LiteralType::Super}145			) {Expr::Literal(v)}>)146147		pub rule expr_basic(s: &ParserSettings) -> LocExpr148			= literal(s)149150			/ string_expr(s) / number_expr(s)151			/ array_expr(s)152			/ obj_expr(s)153			/ array_expr(s)154			/ array_comp_expr(s)155156			/ var_expr(s)157			/ local_expr(s)158			/ if_then_else_expr(s)159160			/ l(s,<keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}>)161			/ l(s,<assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }>)162163			/ l(s,<keyword("error") _ expr:expr(s) { Expr::Error(expr) }>)164165		rule expr_basic_with_suffix(s: &ParserSettings) -> LocExpr166			= a:expr_basic(s) suffixes:(_ suffix:l_expr_suffix(s) {suffix})* {167				let mut cur = a;168				for suffix in suffixes {169					let LocSuffix(suffix, location) = suffix;170					cur = LocExpr(Rc::new(match suffix {171						Suffix::String(index) => Expr::Index(cur, loc_expr!(Expr::Str(index), s.loc_data, (s.file_name.clone(), location.1, location.2))),172						Suffix::Slice(desc) => Expr::Slice(cur, desc),173						Suffix::Expression(index) => Expr::Index(cur, index),174						Suffix::Apply(args) => Expr::Apply(cur, args),175						Suffix::Extend(body) => Expr::ObjExtend(cur, body),176					}), if s.loc_data { Some(Rc::new(location)) } else { None })177				}178				cur179			}180181		pub rule slice_desc(s: &ParserSettings) -> SliceDesc182			= start:expr(s)? _ ":" _ pair:(end:expr(s)? _ step:(":" _ e:expr(s) {e})? {(end, step)})? {183				if let Some((end, step)) = pair {184					SliceDesc { start, end, step }185				}else{186					SliceDesc { start, end: None, step: None }187				}188			}189190		rule expr_suffix(s: &ParserSettings) -> Suffix191			= "." _ s:id() { Suffix::String(s) }192			/ "[" _ s:slice_desc(s) _ "]" { Suffix::Slice(s) }193			/ "[" _ s:expr(s) _ "]" { Suffix::Expression(s) }194			/ "(" _ args:args(s) _ ")" (_ keyword("tailstrict"))? { Suffix::Apply(args) }195			/ "{" _ body:objinside(s) _ "}" { Suffix::Extend(body) }196		rule l_expr_suffix(s: &ParserSettings) -> LocSuffix197			= start:position!() suffix:expr_suffix(s) end:position!() {LocSuffix(suffix, ExprLocation(s.file_name.clone(), start, end))}198199		rule expr(s: &ParserSettings) -> LocExpr200			= start:position!() a:precedence! {201				a:(@) _ "||" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Or, b))}202				--203				a:(@) _ "&&" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::And, b))}204				--205				a:(@) _ "|" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::BitOr, b))}206				--207				a:@ _ "^" _ b:(@) {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::BitXor, b))}208				--209				a:(@) _ "&" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::BitAnd, b))}210				--211				a:(@) _ "==" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Eq, b))}212				a:(@) _ "!=" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Ne, b))}213				--214				a:(@) _ "<" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Lt, b))}215				a:(@) _ ">" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Gt, b))}216				a:(@) _ "<=" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Lte, b))}217				a:(@) _ ">=" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Gte, b))}218				--219				a:(@) _ "<<" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Lhs, b))}220				a:(@) _ ">>" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Rhs, b))}221				--222				a:(@) _ "+" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Add, b))}223				a:(@) _ "-" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Sub, b))}224				--225				a:(@) _ "*" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Mul, b))}226				a:(@) _ "/" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Div, b))}227				a:(@) _ "%" _ b:@ {loc_expr_todo!(Expr::BinaryOp(a, BinaryOpType::Mod, b))}228				--229				e:expr_basic_with_suffix(s) {e}230				"-" _ expr:expr_basic_with_suffix(s) { loc_expr_todo!(Expr::UnaryOp(UnaryOpType::Minus, expr)) }231				"!" _ expr:expr_basic_with_suffix(s) { loc_expr_todo!(Expr::UnaryOp(UnaryOpType::Not, expr)) }232				"(" _ e:expr(s) _ ")" {loc_expr_todo!(Expr::Parened(e))}233			} end:position!() {234				let LocExpr(e, _) = a;235				LocExpr(e, if s.loc_data {236					Some(Rc::new(ExprLocation(s.file_name.to_owned(), start, end)))237				} else {238					None239				})240			}241			/ e:expr_basic_with_suffix(s) {e}242243		pub rule jsonnet(s: &ParserSettings) -> LocExpr = _ e:expr(s) _ {e}244	}245}246247// TODO: impl FromStr from Expr248pub fn parse(249	str: &str,250	settings: &ParserSettings,251) -> Result<LocExpr, peg::error::ParseError<peg::str::LineCol>> {252	jsonnet_parser::jsonnet(str, settings)253}254255#[macro_export]256macro_rules! el {257	($expr:expr) => {258		LocExpr(std::rc::Rc::new($expr), None)259	};260}261262#[cfg(test)]263pub mod tests {264	use super::{expr::*, parse};265	use crate::ParserSettings;266267	macro_rules! parse {268		($s:expr) => {269			parse(270				$s,271				&ParserSettings {272					loc_data: false,273					file_name: "test.jsonnet".to_owned(),274					},275				)276			.unwrap()277		};278	}279280	mod expressions {281		use super::*;282283		pub fn basic_math() -> LocExpr {284			el!(Expr::BinaryOp(285				el!(Expr::Num(2.0)),286				BinaryOpType::Add,287				el!(Expr::BinaryOp(288					el!(Expr::Num(2.0)),289					BinaryOpType::Mul,290					el!(Expr::Num(2.0)),291				)),292			))293		}294	}295296	#[test]297	fn empty_object() {298		assert_eq!(parse!("{}"), el!(Expr::Obj(ObjBody::MemberList(vec![]))));299	}300301	#[test]302	fn basic_math() {303		assert_eq!(304			parse!("2+2*2"),305			el!(Expr::BinaryOp(306				el!(Expr::Num(2.0)),307				BinaryOpType::Add,308				el!(Expr::BinaryOp(309					el!(Expr::Num(2.0)),310					BinaryOpType::Mul,311					el!(Expr::Num(2.0))312				))313			))314		);315	}316317	#[test]318	fn basic_math_with_indents() {319		assert_eq!(parse!("2	+ 	  2	  *	2   	"), expressions::basic_math());320	}321322	#[test]323	fn basic_math_parened() {324		assert_eq!(325			parse!("2+(2+2*2)"),326			el!(Expr::BinaryOp(327				el!(Expr::Num(2.0)),328				BinaryOpType::Add,329				el!(Expr::Parened(expressions::basic_math())),330			))331		);332	}333334	/// Comments should not affect parsing335	#[test]336	fn comments() {337		assert_eq!(338			parse!("2//comment\n+//comment\n3/*test*/*/*test*/4"),339			el!(Expr::BinaryOp(340				el!(Expr::Num(2.0)),341				BinaryOpType::Add,342				el!(Expr::BinaryOp(343					el!(Expr::Num(3.0)),344					BinaryOpType::Mul,345					el!(Expr::Num(4.0))346				))347			))348		);349	}350351	/// Comments should be able to be escaped352	#[test]353	fn comment_escaping() {354		assert_eq!(355			parse!("2/*\\*/+*/ - 22"),356			el!(Expr::BinaryOp(357				el!(Expr::Num(2.0)),358				BinaryOpType::Sub,359				el!(Expr::Num(22.0))360			))361		);362	}363364	#[test]365	fn suffix_comparsion() {366		use Expr::*;367		assert_eq!(368			parse!("std.type(a) == \"string\""),369			el!(BinaryOp(370				el!(Apply(371					el!(Index(372						el!(Var("std".to_owned())),373						el!(Str("type".to_owned()))374					)),375					ArgsDesc(vec![Arg(None, el!(Var("a".to_owned())))])376				)),377				BinaryOpType::Eq,378				el!(Str("string".to_owned()))379			))380		);381	}382383	#[test]384	fn array_comp() {385		use Expr::*;386		assert_eq!(387			parse!("[std.deepJoin(x) for x in arr]"),388			el!(ArrComp(389				el!(Apply(390					el!(Index(391						el!(Var("std".to_owned())),392						el!(Str("deepJoin".to_owned()))393					)),394					ArgsDesc(vec![Arg(None, el!(Var("x".to_owned())))])395				)),396				vec![CompSpec::ForSpec(ForSpecData(397					"x".to_owned(),398					el!(Var("arr".to_owned()))399				))]400			)),401		)402	}403404	#[test]405	fn array_comp_with_ifs() {406		use Expr::*;407		assert_eq!(408			parse!("[k for k in std.objectFields(patch) if patch[k] == null]"),409			el!(ArrComp(410				el!(Var("k".to_owned())),411				vec![412					CompSpec::ForSpec(ForSpecData(413						"k".to_owned(),414						el!(Apply(415							el!(Index(416								el!(Var("std".to_owned())),417								el!(Str("objectFields".to_owned()))418							)),419							ArgsDesc(vec![Arg(None, el!(Var("patch".to_owned())))])420						))421					)),422					CompSpec::IfSpec(IfSpecData(el!(BinaryOp(423						el!(Index(424							el!(Var("patch".to_owned())),425							el!(Var("k".to_owned()))426						)),427						BinaryOpType::Eq,428						el!(Literal(LiteralType::Null))429					))))430				]431			))432		);433	}434435	#[test]436	fn reserved() {437		use Expr::*;438		assert_eq!(parse!("null"), el!(Literal(LiteralType::Null)));439		assert_eq!(parse!("nulla"), el!(Var("nulla".to_owned())));440	}441442	#[test]443	fn multiple_args_buf() {444		parse!("a(b, null_fields)");445	}446447	#[test]448	fn infix_precedence() {449		use Expr::*;450		assert_eq!(451			parse!("!a && !b"),452			el!(BinaryOp(453				el!(UnaryOp(UnaryOpType::Not, el!(Var("a".to_owned())))),454				BinaryOpType::And,455				el!(UnaryOp(UnaryOpType::Not, el!(Var("b".to_owned()))))456			))457		);458	}459460	#[test]461	fn can_parse_stdlib() {462		parse!(jsonnet_stdlib::STDLIB_STR);463	}464}