1#![allow(clippy::redundant_closure_call, clippy::derive_partial_eq_without_eq)]23use std::rc::Rc;45use peg::parser;6mod expr;7pub use expr::*;8pub use jrsonnet_interner::IStr;9pub use peg;10mod location;11mod source;12mod unescape;13pub use location::CodeLocation;14pub use source::{Source, SourceDirectory, SourceFile, SourcePath, SourcePathT, SourceVirtual};1516pub struct ParserSettings {17 pub file_name: Source,18}1920macro_rules! expr_bin {21 ($a:ident $op:ident $b:ident) => {22 Expr::BinaryOp($a, $op, $b)23 };24}25macro_rules! expr_un {26 ($op:ident $a:ident) => {27 Expr::UnaryOp($op, $a)28 };29}3031parser! {32 grammar jsonnet_parser() for str {33 use peg::ParseLiteral;3435 rule eof() = quiet!{![_]} / expected!("<eof>")36 rule eol() = "\n" / eof()3738 39 rule comment()40 = "//" (!eol()[_])* eol()41 / "/*" ("\\*/" / "\\\\" / (!("*/")[_]))* "*/"42 / "#" (!eol()[_])* eol()4344 rule single_whitespace() = quiet!{([' ' | '\r' | '\n' | '\t'] / comment())} / expected!("<whitespace>")45 rule _() = quiet!{([' ' | '\r' | '\n' | '\t']+) / comment()}* / expected!("<whitespace>")4647 48 rule comma() = quiet!{_ "," _} / expected!("<comma>")49 rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().next().unwrap()}50 rule digit() -> char = d:$(['0'..='9']) {d.chars().next().unwrap()}51 rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']52 53 rule uint_str() -> &'input str = a:$(digit()+) { a }54 55 rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.parse().map_err(|_| "<number>") }} / expected!("<number>")5657 58 rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()59 rule id() -> IStr = v:$(quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")) { v.into() }6061 rule keyword(id: &'static str) -> ()62 = ##parse_string_literal(id) end_of_ident()6364 pub rule param(s: &ParserSettings) -> expr::Param = name:destruct(s) expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name, expr) }65 pub rule params(s: &ParserSettings) -> expr::ParamsDesc66 = params:param(s) ** comma() comma()? { expr::ParamsDesc(Rc::new(params)) }67 / { expr::ParamsDesc(Rc::new(Vec::new())) }6869 pub rule arg(s: &ParserSettings) -> (Option<IStr>, LocExpr)70 = quiet! { name:(s:id() _ "=" !['='] _ {s})? expr:expr(s) {(name, expr)} }71 / expected!("<argument>")7273 pub rule args(s: &ParserSettings) -> expr::ArgsDesc74 = args:arg(s)**comma() comma()? {?75 let unnamed_count = args.iter().take_while(|(n, _)| n.is_none()).count();76 let mut unnamed = Vec::with_capacity(unnamed_count);77 let mut named = Vec::with_capacity(args.len() - unnamed_count);78 let mut named_started = false;79 for (name, value) in args {80 if let Some(name) = name {81 named_started = true;82 named.push((name, value));83 } else {84 if named_started {85 return Err("<named argument>")86 }87 unnamed.push(value);88 }89 }90 Ok(expr::ArgsDesc::new(unnamed, named))91 }9293 pub rule destruct_rest() -> expr::DestructRest94 = "..." into:(_ into:id() {into})? {if let Some(into) = into {95 expr::DestructRest::Keep(into)96 } else {expr::DestructRest::Drop}}97 pub rule destruct_array(s: &ParserSettings) -> expr::Destruct98 = "[" _ start:destruct(s)**comma() rest:(99 comma() _ rest:destruct_rest()? end:(100 comma() end:destruct(s)**comma() (_ comma())? {end}101 / comma()? {Vec::new()}102 ) {(rest, end)}103 / comma()? {(None, Vec::new())}104 ) _ "]" {?105 #[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Array {106 start,107 rest: rest.0,108 end: rest.1,109 });110 #[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")111 }112 pub rule destruct_object(s: &ParserSettings) -> expr::Destruct113 = "{" _114 fields:(name:id() into:(_ ":" _ into:destruct(s) {into})? default:(_ "=" _ v:expr(s) {v})? {(name, into, default)})**comma()115 rest:(116 comma() rest:destruct_rest()? {rest}117 / comma()? {None}118 )119 _ "}" {?120 #[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Object {121 fields,122 rest,123 });124 #[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")125 }126 pub rule destruct(s: &ParserSettings) -> expr::Destruct127 = v:id() {expr::Destruct::Full(v)}128 / "?" {?129 #[cfg(feature = "exp-destruct")] return Ok(expr::Destruct::Skip);130 #[cfg(not(feature = "exp-destruct"))] Err("experimental destructuring was not enabled")131 }132 / arr:destruct_array(s) {arr}133 / obj:destruct_object(s) {obj}134135 pub rule bind(s: &ParserSettings) -> expr::BindSpec136 = into:destruct(s) _ "=" _ expr:expr(s) {expr::BindSpec::Field{into, value: expr}}137 / name:id() _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec::Function{name, params, value: expr}}138139 pub rule assertion(s: &ParserSettings) -> expr::AssertStmt140 = keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }141142 pub rule whole_line() -> &'input str143 = str:$((!['\n'][_])* "\n") {str}144 pub rule string_block() -> String145 = "|||" (!['\n']single_whitespace())* "\n"146 empty_lines:$(['\n']*)147 prefix:[' ' | '\t']+ first_line:whole_line()148 lines:("\n" {"\n"} / [' ' | '\t']*<{prefix.len()}> s:whole_line() {s})*149 [' ' | '\t']*<, {prefix.len() - 1}> "|||"150 {let mut l = empty_lines.to_owned(); l.push_str(first_line); l.extend(lines); l}151152 rule hex_char()153 = quiet! { ['0'..='9' | 'a'..='f' | 'A'..='F'] } / expected!("<hex char>")154155 rule string_char(c: rule<()>)156 = (!['\\']!c()[_])+157 / "\\\\"158 / "\\u" hex_char() hex_char() hex_char() hex_char()159 / "\\x" hex_char() hex_char()160 / ['\\'] (quiet! { ['b' | 'f' | 'n' | 'r' | 't' | '"' | '\''] } / expected!("<escape character>"))161 pub rule string() -> String162 = ['"'] str:$(string_char(<"\"">)*) ['"'] {? unescape::unescape(str).ok_or("<escaped string>")}163 / ['\''] str:$(string_char(<"\'">)*) ['\''] {? unescape::unescape(str).ok_or("<escaped string>")}164 / quiet!{ "@'" str:$(("''" / (!['\''][_]))*) "'" {str.replace("''", "'")}165 / "@\"" str:$(("\"\"" / (!['"'][_]))*) "\"" {str.replace("\"\"", "\"")}166 / string_block() } / expected!("<string>")167168 pub rule field_name(s: &ParserSettings) -> expr::FieldName169 = name:id() {expr::FieldName::Fixed(name)}170 / name:string() {expr::FieldName::Fixed(name.into())}171 / "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}172 pub rule visibility() -> expr::Visibility173 = ":::" {expr::Visibility::Unhide}174 / "::" {expr::Visibility::Hidden}175 / ":" {expr::Visibility::Normal}176 pub rule field(s: &ParserSettings) -> expr::FieldMember177 = name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {expr::FieldMember{178 name,179 plus: plus.is_some(),180 params: None,181 visibility,182 value,183 }}184 / name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {expr::FieldMember{185 name,186 plus: false,187 params: Some(params),188 visibility,189 value,190 }}191 pub rule obj_local(s: &ParserSettings) -> BindSpec192 = keyword("local") _ bind:bind(s) {bind}193 pub rule member(s: &ParserSettings) -> expr::Member194 = bind:obj_local(s) {expr::Member::BindStmt(bind)}195 / assertion:assertion(s) {expr::Member::AssertStmt(assertion)}196 / field:field(s) {expr::Member::Field(field)}197 pub rule objinside(s: &ParserSettings) -> expr::ObjBody198 = 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})? {199 let mut compspecs = vec![CompSpec::ForSpec(forspec)];200 compspecs.extend(others.unwrap_or_default());201 expr::ObjBody::ObjComp(expr::ObjComp{202 pre_locals,203 key,204 plus: plus.is_some(),205 value,206 post_locals,207 compspecs,208 })209 }210 / members:(member(s) ** comma()) comma()? {expr::ObjBody::MemberList(members)}211 pub rule ifspec(s: &ParserSettings) -> IfSpecData212 = keyword("if") _ expr:expr(s) {IfSpecData(expr)}213 pub rule forspec(s: &ParserSettings) -> ForSpecData214 = keyword("for") _ id:id() _ keyword("in") _ cond:expr(s) {ForSpecData(id, cond)}215 pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec>216 = s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} ) ** _ {s}217 pub rule local_expr(s: &ParserSettings) -> Expr218 = keyword("local") _ binds:bind(s) ** comma() (_ ",")? _ ";" _ expr:expr(s) { Expr::LocalExpr(binds, expr) }219 pub rule string_expr(s: &ParserSettings) -> Expr220 = s:string() {Expr::Str(s.into())}221 pub rule obj_expr(s: &ParserSettings) -> Expr222 = "{" _ body:objinside(s) _ "}" {Expr::Obj(body)}223 pub rule array_expr(s: &ParserSettings) -> Expr224 = "[" _ elems:(expr(s) ** comma()) _ comma()? "]" {Expr::Arr(elems)}225 pub rule array_comp_expr(s: &ParserSettings) -> Expr226 = "[" _ expr:expr(s) _ comma()? _ forspec:forspec(s) _ others:(others: compspec(s) _ {others})? "]" {227 let mut specs = vec![CompSpec::ForSpec(forspec)];228 specs.extend(others.unwrap_or_default());229 Expr::ArrComp(expr, specs)230 }231 pub rule number_expr(s: &ParserSettings) -> Expr232 = n:number() { expr::Expr::Num(n) }233 pub rule var_expr(s: &ParserSettings) -> Expr234 = n:id() { expr::Expr::Var(n) }235 pub rule id_loc(s: &ParserSettings) -> LocExpr236 = a:position!() n:id() b:position!() { LocExpr(Rc::new(expr::Expr::Str(n)), ExprLocation(s.file_name.clone(), a as u32,b as u32)) }237 pub rule if_then_else_expr(s: &ParserSettings) -> Expr238 = cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse{239 cond,240 cond_then,241 cond_else,242 }}243244 pub rule literal(s: &ParserSettings) -> Expr245 = v:(246 keyword("null") {LiteralType::Null}247 / keyword("true") {LiteralType::True}248 / keyword("false") {LiteralType::False}249 / keyword("self") {LiteralType::This}250 / keyword("$") {LiteralType::Dollar}251 / keyword("super") {LiteralType::Super}252 ) {Expr::Literal(v)}253254 pub rule expr_basic(s: &ParserSettings) -> Expr255 = literal(s)256257 / string_expr(s) / number_expr(s)258 / array_expr(s)259 / obj_expr(s)260 / array_expr(s)261 / array_comp_expr(s)262263 / keyword("importstr") _ path:string() {Expr::ImportStr(path.into())}264 / keyword("importbin") _ path:string() {Expr::ImportBin(path.into())}265 / keyword("import") _ path:string() {Expr::Import(path.into())}266267 / var_expr(s)268 / local_expr(s)269 / if_then_else_expr(s)270271 / keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}272 / assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }273274 / keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }275276 rule slice_part(s: &ParserSettings) -> Option<LocExpr>277 = _ e:(e:expr(s) _{e})? {e}278 pub rule slice_desc(s: &ParserSettings) -> SliceDesc279 = start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {280 let (end, step) = if let Some((end, step)) = pair {281 (end, step)282 }else{283 (None, None)284 };285286 SliceDesc { start, end, step }287 }288289 rule binop(x: rule<()>) -> ()290 = quiet!{ x() } / expected!("<binary op>")291 rule unaryop(x: rule<()>) -> ()292 = quiet!{ x() } / expected!("<unary op>")293294295 use BinaryOpType::*;296 use UnaryOpType::*;297 rule expr(s: &ParserSettings) -> LocExpr298 = precedence! {299 start:position!() v:@ end:position!() { LocExpr(Rc::new(v), ExprLocation(s.file_name.clone(), start as u32, end as u32)) }300 --301 a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}302 --303 a:(@) _ binop(<"&&">) _ b:@ {expr_bin!(a And b)}304 --305 a:(@) _ binop(<"|">) _ b:@ {expr_bin!(a BitOr b)}306 --307 a:@ _ binop(<"^">) _ b:(@) {expr_bin!(a BitXor b)}308 --309 a:(@) _ binop(<"&">) _ b:@ {expr_bin!(a BitAnd b)}310 --311 a:(@) _ binop(<"==">) _ b:@ {expr_bin!(a Eq b)}312 a:(@) _ binop(<"!=">) _ b:@ {expr_bin!(a Neq b)}313 --314 a:(@) _ binop(<"<">) _ b:@ {expr_bin!(a Lt b)}315 a:(@) _ binop(<">">) _ b:@ {expr_bin!(a Gt b)}316 a:(@) _ binop(<"<=">) _ b:@ {expr_bin!(a Lte b)}317 a:(@) _ binop(<">=">) _ b:@ {expr_bin!(a Gte b)}318 a:(@) _ binop(<keyword("in")>) _ b:@ {expr_bin!(a In b)}319 --320 a:(@) _ binop(<"<<">) _ b:@ {expr_bin!(a Lhs b)}321 a:(@) _ binop(<">>">) _ b:@ {expr_bin!(a Rhs b)}322 --323 a:(@) _ binop(<"+">) _ b:@ {expr_bin!(a Add b)}324 a:(@) _ binop(<"-">) _ b:@ {expr_bin!(a Sub b)}325 --326 a:(@) _ binop(<"*">) _ b:@ {expr_bin!(a Mul b)}327 a:(@) _ binop(<"/">) _ b:@ {expr_bin!(a Div b)}328 a:(@) _ binop(<"%">) _ b:@ {expr_bin!(a Mod b)}329 --330 unaryop(<"-">) _ b:@ {expr_un!(Minus b)}331 unaryop(<"!">) _ b:@ {expr_un!(Not b)}332 unaryop(<"~">) _ b:@ {expr_un!(BitNot b)}333 --334 a:(@) _ "[" _ e:slice_desc(s) _ "]" {Expr::Slice(a, e)}335 a:(@) _ "." _ a:position!() e:id_loc(s) b:position!() {Expr::Index(a, e)}336 a:(@) _ "[" _ e:expr(s) _ "]" {Expr::Index(a, e)}337 a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(a, args, ts.is_some())}338 a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(a, body)}339 --340 e:expr_basic(s) {e}341 "(" _ e:expr(s) _ ")" {Expr::Parened(e)}342 }343344 pub rule jsonnet(s: &ParserSettings) -> LocExpr = _ e:expr(s) _ {e}345 }346}347348pub type ParseError = peg::error::ParseError<peg::str::LineCol>;349pub fn parse(str: &str, settings: &ParserSettings) -> Result<LocExpr, ParseError> {350 jsonnet_parser::jsonnet(str, settings)351}352353pub fn string_to_expr(str: IStr, settings: &ParserSettings) -> LocExpr {354 let len = str.len();355 LocExpr(356 Rc::new(Expr::Str(str)),357 ExprLocation(settings.file_name.clone(), 0, len as u32),358 )359}360361#[cfg(test)]362pub mod tests {363 use jrsonnet_interner::IStr;364 use BinaryOpType::*;365366 use super::{expr::*, parse};367 use crate::{source::Source, ParserSettings};368369 macro_rules! parse {370 ($s:expr) => {371 parse(372 $s,373 &ParserSettings {374 file_name: Source::new_virtual("<test>".into(), IStr::empty()),375 },376 )377 .unwrap()378 };379 }380381 macro_rules! el {382 ($expr:expr, $from:expr, $to:expr$(,)?) => {383 LocExpr(384 std::rc::Rc::new($expr),385 ExprLocation(386 Source::new_virtual("<test>".into(), IStr::empty()),387 $from,388 $to,389 ),390 )391 };392 }393394 #[test]395 fn multiline_string() {396 assert_eq!(397 parse!("|||\n Hello world!\n a\n|||"),398 el!(Expr::Str("Hello world!\n a\n".into()), 0, 31),399 );400 assert_eq!(401 parse!("|||\n Hello world!\n a\n|||"),402 el!(Expr::Str("Hello world!\n a\n".into()), 0, 27),403 );404 assert_eq!(405 parse!("|||\n\t\tHello world!\n\t\t\ta\n|||"),406 el!(Expr::Str("Hello world!\n\ta\n".into()), 0, 27),407 );408 assert_eq!(409 parse!("|||\n Hello world!\n a\n |||"),410 el!(Expr::Str("Hello world!\n a\n".into()), 0, 30),411 );412 }413414 #[test]415 fn slice() {416 parse!("a[1:]");417 parse!("a[1::]");418 parse!("a[:1:]");419 parse!("a[::1]");420 parse!("str[:len - 1]");421 }422423 #[test]424 fn string_escaping() {425 assert_eq!(426 parse!(r#""Hello, \"world\"!""#),427 el!(Expr::Str(r#"Hello, "world"!"#.into()), 0, 19),428 );429 assert_eq!(430 parse!(r#"'Hello \'world\'!'"#),431 el!(Expr::Str("Hello 'world'!".into()), 0, 18),432 );433 assert_eq!(parse!(r#"'\\\\'"#), el!(Expr::Str("\\\\".into()), 0, 6));434 }435436 #[test]437 fn string_unescaping() {438 assert_eq!(439 parse!(r#""Hello\nWorld""#),440 el!(Expr::Str("Hello\nWorld".into()), 0, 14),441 );442 }443444 #[test]445 fn string_verbantim() {446 assert_eq!(447 parse!(r#"@"Hello\n""World""""#),448 el!(Expr::Str("Hello\\n\"World\"".into()), 0, 19),449 );450 }451452 #[test]453 fn imports() {454 assert_eq!(455 parse!("import \"hello\""),456 el!(Expr::Import("hello".into()), 0, 14),457 );458 assert_eq!(459 parse!("importstr \"garnish.txt\""),460 el!(Expr::ImportStr("garnish.txt".into()), 0, 23)461 );462 assert_eq!(463 parse!("importbin \"garnish.bin\""),464 el!(Expr::ImportBin("garnish.bin".into()), 0, 23)465 );466 }467468 #[test]469 fn empty_object() {470 assert_eq!(471 parse!("{}"),472 el!(Expr::Obj(ObjBody::MemberList(vec![])), 0, 2)473 );474 }475476 #[test]477 fn basic_math() {478 assert_eq!(479 parse!("2+2*2"),480 el!(481 Expr::BinaryOp(482 el!(Expr::Num(2.0), 0, 1),483 Add,484 el!(485 Expr::BinaryOp(el!(Expr::Num(2.0), 2, 3), Mul, el!(Expr::Num(2.0), 4, 5)),486 2,487 5488 )489 ),490 0,491 5492 )493 );494 }495496 #[test]497 fn basic_math_with_indents() {498 assert_eq!(499 parse!("2 + 2 * 2 "),500 el!(501 Expr::BinaryOp(502 el!(Expr::Num(2.0), 0, 1),503 Add,504 el!(505 Expr::BinaryOp(el!(Expr::Num(2.0), 7, 8), Mul, el!(Expr::Num(2.0), 13, 14),),506 7,507 14508 ),509 ),510 0,511 14512 )513 );514 }515516 #[test]517 fn basic_math_parened() {518 assert_eq!(519 parse!("2+(2+2*2)"),520 el!(521 Expr::BinaryOp(522 el!(Expr::Num(2.0), 0, 1),523 Add,524 el!(525 Expr::Parened(el!(526 Expr::BinaryOp(527 el!(Expr::Num(2.0), 3, 4),528 Add,529 el!(530 Expr::BinaryOp(531 el!(Expr::Num(2.0), 5, 6),532 Mul,533 el!(Expr::Num(2.0), 7, 8),534 ),535 5,536 8537 ),538 ),539 3,540 8541 )),542 2,543 9544 ),545 ),546 0,547 9548 )549 );550 }551552 553 #[test]554 fn comments() {555 assert_eq!(556 parse!("2//comment\n+//comment\n3/*test*/*/*test*/4"),557 el!(558 Expr::BinaryOp(559 el!(Expr::Num(2.0), 0, 1),560 Add,561 el!(562 Expr::BinaryOp(563 el!(Expr::Num(3.0), 22, 23),564 Mul,565 el!(Expr::Num(4.0), 40, 41)566 ),567 22,568 41569 )570 ),571 0,572 41573 )574 );575 }576577 578 #[test]579 fn comment_escaping() {580 assert_eq!(581 parse!("2/*\\*/+*/ - 22"),582 el!(583 Expr::BinaryOp(el!(Expr::Num(2.0), 0, 1), Sub, el!(Expr::Num(22.0), 12, 14)),584 0,585 14586 )587 );588 }589590 #[test]591 fn suffix() {592 593 594 595 596 }597598 #[test]599 fn array_comp() {600 use Expr::*;601 602603604605 assert_eq!(606 parse!("[std.deepJoin(x) for x in arr]"),607 el!(608 ArrComp(609 el!(610 Apply(611 el!(612 Index(613 el!(Var("std".into()), 1, 4),614 el!(Str("deepJoin".into()), 5, 13)615 ),616 1,617 13618 ),619 ArgsDesc::new(vec![el!(Var("x".into()), 14, 15)], vec![]),620 false,621 ),622 1,623 16624 ),625 vec![CompSpec::ForSpec(ForSpecData(626 "x".into(),627 el!(Var("arr".into()), 26, 29)628 ))]629 ),630 0,631 30632 ),633 )634 }635636 #[test]637 fn reserved() {638 use Expr::*;639 assert_eq!(parse!("null"), el!(Literal(LiteralType::Null), 0, 4));640 assert_eq!(parse!("nulla"), el!(Var("nulla".into()), 0, 5));641 }642643 #[test]644 fn multiple_args_buf() {645 parse!("a(b, null_fields)");646 }647648 #[test]649 fn infix_precedence() {650 use Expr::*;651 assert_eq!(652 parse!("!a && !b"),653 el!(654 BinaryOp(655 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),656 And,657 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 7, 8)), 6, 8)658 ),659 0,660 8661 )662 );663 }664665 #[test]666 fn infix_precedence_division() {667 use Expr::*;668 assert_eq!(669 parse!("!a / !b"),670 el!(671 BinaryOp(672 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),673 Div,674 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 6, 7)), 5, 7)675 ),676 0,677 7678 )679 );680 }681682 #[test]683 fn double_negation() {684 use Expr::*;685 assert_eq!(686 parse!("!!a"),687 el!(688 UnaryOp(689 UnaryOpType::Not,690 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 2, 3)), 1, 3)691 ),692 0,693 3694 )695 )696 }697698 #[test]699 fn array_test_error() {700 parse!("[a for a in b if c for e in f]");701 702 }703704 #[test]705 fn missing_newline_between_comment_and_eof() {706 parse!(707 "{a:1}708709 //+213"710 );711 }712713 #[test]714 fn default_param_before_nondefault() {715 parse!("local x(foo = 'foo', bar) = null; null");716 }717718 #[test]719 fn add_location_info_to_all_sub_expressions() {720 use Expr::*;721722 let file_name = Source::new_virtual("<test>".into(), IStr::empty());723 let expr = parse(724 "{} { local x = 1, x: x } + {}",725 &ParserSettings { file_name },726 )727 .unwrap();728 assert_eq!(729 expr,730 el!(731 BinaryOp(732 el!(733 ObjExtend(734 el!(Obj(ObjBody::MemberList(vec![])), 0, 2),735 ObjBody::MemberList(vec![736 Member::BindStmt(BindSpec::Field {737 into: Destruct::Full("x".into()),738 value: el!(Num(1.0), 15, 16)739 }),740 Member::Field(FieldMember {741 name: FieldName::Fixed("x".into()),742 plus: false,743 params: None,744 visibility: Visibility::Normal,745 value: el!(Var("x".into()), 21, 22),746 })747 ])748 ),749 0,750 24751 ),752 BinaryOpType::Add,753 el!(Obj(ObjBody::MemberList(vec![])), 27, 29),754 ),755 0,756 29757 ),758 );759 }760}