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 std::borrow::Cow;364365 use jrsonnet_interner::IStr;366 use BinaryOpType::*;367368 use super::{expr::*, parse};369 use crate::{source::Source, ParserSettings};370371 macro_rules! parse {372 ($s:expr) => {373 parse(374 $s,375 &ParserSettings {376 file_name: Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty()),377 },378 )379 .unwrap()380 };381 }382383 macro_rules! el {384 ($expr:expr, $from:expr, $to:expr$(,)?) => {385 LocExpr(386 std::rc::Rc::new($expr),387 ExprLocation(388 Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty()),389 $from,390 $to,391 ),392 )393 };394 }395396 #[test]397 fn multiline_string() {398 assert_eq!(399 parse!("|||\n Hello world!\n a\n|||"),400 el!(Expr::Str("Hello world!\n a\n".into()), 0, 31),401 );402 assert_eq!(403 parse!("|||\n Hello world!\n a\n|||"),404 el!(Expr::Str("Hello world!\n a\n".into()), 0, 27),405 );406 assert_eq!(407 parse!("|||\n\t\tHello world!\n\t\t\ta\n|||"),408 el!(Expr::Str("Hello world!\n\ta\n".into()), 0, 27),409 );410 assert_eq!(411 parse!("|||\n Hello world!\n a\n |||"),412 el!(Expr::Str("Hello world!\n a\n".into()), 0, 30),413 );414 }415416 #[test]417 fn slice() {418 parse!("a[1:]");419 parse!("a[1::]");420 parse!("a[:1:]");421 parse!("a[::1]");422 parse!("str[:len - 1]");423 }424425 #[test]426 fn string_escaping() {427 assert_eq!(428 parse!(r#""Hello, \"world\"!""#),429 el!(Expr::Str(r#"Hello, "world"!"#.into()), 0, 19),430 );431 assert_eq!(432 parse!(r#"'Hello \'world\'!'"#),433 el!(Expr::Str("Hello 'world'!".into()), 0, 18),434 );435 assert_eq!(parse!(r#"'\\\\'"#), el!(Expr::Str("\\\\".into()), 0, 6));436 }437438 #[test]439 fn string_unescaping() {440 assert_eq!(441 parse!(r#""Hello\nWorld""#),442 el!(Expr::Str("Hello\nWorld".into()), 0, 14),443 );444 }445446 #[test]447 fn string_verbantim() {448 assert_eq!(449 parse!(r#"@"Hello\n""World""""#),450 el!(Expr::Str("Hello\\n\"World\"".into()), 0, 19),451 );452 }453454 #[test]455 fn imports() {456 assert_eq!(457 parse!("import \"hello\""),458 el!(Expr::Import("hello".into()), 0, 14),459 );460 assert_eq!(461 parse!("importstr \"garnish.txt\""),462 el!(Expr::ImportStr("garnish.txt".into()), 0, 23)463 );464 assert_eq!(465 parse!("importbin \"garnish.bin\""),466 el!(Expr::ImportBin("garnish.bin".into()), 0, 23)467 );468 }469470 #[test]471 fn empty_object() {472 assert_eq!(473 parse!("{}"),474 el!(Expr::Obj(ObjBody::MemberList(vec![])), 0, 2)475 );476 }477478 #[test]479 fn basic_math() {480 assert_eq!(481 parse!("2+2*2"),482 el!(483 Expr::BinaryOp(484 el!(Expr::Num(2.0), 0, 1),485 Add,486 el!(487 Expr::BinaryOp(el!(Expr::Num(2.0), 2, 3), Mul, el!(Expr::Num(2.0), 4, 5)),488 2,489 5490 )491 ),492 0,493 5494 )495 );496 }497498 #[test]499 fn basic_math_with_indents() {500 assert_eq!(501 parse!("2 + 2 * 2 "),502 el!(503 Expr::BinaryOp(504 el!(Expr::Num(2.0), 0, 1),505 Add,506 el!(507 Expr::BinaryOp(el!(Expr::Num(2.0), 7, 8), Mul, el!(Expr::Num(2.0), 13, 14),),508 7,509 14510 ),511 ),512 0,513 14514 )515 );516 }517518 #[test]519 fn basic_math_parened() {520 assert_eq!(521 parse!("2+(2+2*2)"),522 el!(523 Expr::BinaryOp(524 el!(Expr::Num(2.0), 0, 1),525 Add,526 el!(527 Expr::Parened(el!(528 Expr::BinaryOp(529 el!(Expr::Num(2.0), 3, 4),530 Add,531 el!(532 Expr::BinaryOp(533 el!(Expr::Num(2.0), 5, 6),534 Mul,535 el!(Expr::Num(2.0), 7, 8),536 ),537 5,538 8539 ),540 ),541 3,542 8543 )),544 2,545 9546 ),547 ),548 0,549 9550 )551 );552 }553554 555 #[test]556 fn comments() {557 assert_eq!(558 parse!("2//comment\n+//comment\n3/*test*/*/*test*/4"),559 el!(560 Expr::BinaryOp(561 el!(Expr::Num(2.0), 0, 1),562 Add,563 el!(564 Expr::BinaryOp(565 el!(Expr::Num(3.0), 22, 23),566 Mul,567 el!(Expr::Num(4.0), 40, 41)568 ),569 22,570 41571 )572 ),573 0,574 41575 )576 );577 }578579 580 #[test]581 fn comment_escaping() {582 assert_eq!(583 parse!("2/*\\*/+*/ - 22"),584 el!(585 Expr::BinaryOp(el!(Expr::Num(2.0), 0, 1), Sub, el!(Expr::Num(22.0), 12, 14)),586 0,587 14588 )589 );590 }591592 #[test]593 fn suffix() {594 595 596 597 598 }599600 #[test]601 fn array_comp() {602 use Expr::*;603 604605606607 assert_eq!(608 parse!("[std.deepJoin(x) for x in arr]"),609 el!(610 ArrComp(611 el!(612 Apply(613 el!(614 Index(615 el!(Var("std".into()), 1, 4),616 el!(Str("deepJoin".into()), 5, 13)617 ),618 1,619 13620 ),621 ArgsDesc::new(vec![el!(Var("x".into()), 14, 15)], vec![]),622 false,623 ),624 1,625 16626 ),627 vec![CompSpec::ForSpec(ForSpecData(628 "x".into(),629 el!(Var("arr".into()), 26, 29)630 ))]631 ),632 0,633 30634 ),635 )636 }637638 #[test]639 fn reserved() {640 use Expr::*;641 assert_eq!(parse!("null"), el!(Literal(LiteralType::Null), 0, 4));642 assert_eq!(parse!("nulla"), el!(Var("nulla".into()), 0, 5));643 }644645 #[test]646 fn multiple_args_buf() {647 parse!("a(b, null_fields)");648 }649650 #[test]651 fn infix_precedence() {652 use Expr::*;653 assert_eq!(654 parse!("!a && !b"),655 el!(656 BinaryOp(657 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),658 And,659 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 7, 8)), 6, 8)660 ),661 0,662 8663 )664 );665 }666667 #[test]668 fn infix_precedence_division() {669 use Expr::*;670 assert_eq!(671 parse!("!a / !b"),672 el!(673 BinaryOp(674 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),675 Div,676 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 6, 7)), 5, 7)677 ),678 0,679 7680 )681 );682 }683684 #[test]685 fn double_negation() {686 use Expr::*;687 assert_eq!(688 parse!("!!a"),689 el!(690 UnaryOp(691 UnaryOpType::Not,692 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 2, 3)), 1, 3)693 ),694 0,695 3696 )697 )698 }699700 #[test]701 fn array_test_error() {702 parse!("[a for a in b if c for e in f]");703 704 }705706 #[test]707 fn missing_newline_between_comment_and_eof() {708 parse!(709 "{a:1}710711 //+213"712 );713 }714715 #[test]716 fn default_param_before_nondefault() {717 parse!("local x(foo = 'foo', bar) = null; null");718 }719720 #[test]721 fn add_location_info_to_all_sub_expressions() {722 use Expr::*;723724 let file_name = Source::new_virtual(Cow::Borrowed("<test>"), IStr::empty());725 let expr = parse(726 "{} { local x = 1, x: x } + {}",727 &ParserSettings { file_name },728 )729 .unwrap();730 assert_eq!(731 expr,732 el!(733 BinaryOp(734 el!(735 ObjExtend(736 el!(Obj(ObjBody::MemberList(vec![])), 0, 2),737 ObjBody::MemberList(vec![738 Member::BindStmt(BindSpec::Field {739 into: Destruct::Full("x".into()),740 value: el!(Num(1.0), 15, 16)741 }),742 Member::Field(FieldMember {743 name: FieldName::Fixed("x".into()),744 plus: false,745 params: None,746 visibility: Visibility::Normal,747 value: el!(Var("x".into()), 21, 22),748 })749 ])750 ),751 0,752 24753 ),754 BinaryOpType::Add,755 el!(Obj(ObjBody::MemberList(vec![])), 27, 29),756 ),757 0,758 29759 ),760 );761 }762}