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 27 rule comment() = "//" (!['\n'][_])* "\n" / "/*" ((!("*/")[_][_])/("\\" "*/"))* "*/"28 rule _() = ([' ' | '\n' | '\t'] / comment())*2930 31 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 36 rule uint() -> u32 = a:$(digit()+) { a.parse().unwrap() }37 38 rule number() -> f64 = quiet!{a:$(uint() ("." uint())? (['e'|'E'] (s:['+'|'-'])? uint())?) { a.parse().unwrap() }} / expected!("<number>")3940 41 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 ¶ms {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}246247248pub 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 335 #[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 352 #[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}