1#![allow(clippy::redundant_closure_call)]23use std::{4 path::{Path, PathBuf},5 rc::Rc,6};78use peg::parser;9mod expr;10pub use expr::*;11pub use jrsonnet_interner::IStr;12pub use peg;13mod unescape;1415pub struct ParserSettings {16 pub file_name: Rc<Path>,17}1819macro_rules! expr_bin {20 ($a:ident $op:ident $b:ident) => {21 Expr::BinaryOp($a, $op, $b)22 };23}24macro_rules! expr_un {25 ($op:ident $a:ident) => {26 Expr::UnaryOp($op, $a)27 };28}2930parser! {31 grammar jsonnet_parser() for str {32 use peg::ParseLiteral;3334 rule eof() = quiet!{![_]} / expected!("<eof>")35 rule eol() = "\n" / eof()3637 38 rule comment()39 = "//" (!eol()[_])* eol()40 / "/*" ("\\*/" / "\\\\" / (!("*/")[_]))* "*/"41 / "#" (!eol()[_])* eol()4243 rule single_whitespace() = quiet!{([' ' | '\r' | '\n' | '\t'] / comment())} / expected!("<whitespace>")44 rule _() = quiet!{([' ' | '\r' | '\n' | '\t']+) / comment()}* / expected!("<whitespace>")4546 47 rule comma() = quiet!{_ "," _} / expected!("<comma>")48 rule alpha() -> char = c:$(['_' | 'a'..='z' | 'A'..='Z']) {c.chars().next().unwrap()}49 rule digit() -> char = d:$(['0'..='9']) {d.chars().next().unwrap()}50 rule end_of_ident() = !['0'..='9' | '_' | 'a'..='z' | 'A'..='Z']51 52 rule uint_str() -> &'input str = a:$(digit()+) { a }53 54 rule number() -> f64 = quiet!{a:$(uint_str() ("." uint_str())? (['e'|'E'] (s:['+'|'-'])? uint_str())?) {? a.parse().map_err(|_| "<number>") }} / expected!("<number>")5556 57 rule reserved() = ("assert" / "else" / "error" / "false" / "for" / "function" / "if" / "import" / "importstr" / "importbin" / "in" / "local" / "null" / "tailstrict" / "then" / "self" / "super" / "true") end_of_ident()58 rule id() = quiet!{ !reserved() alpha() (alpha() / digit())*} / expected!("<identifier>")5960 rule keyword(id: &'static str) -> ()61 = ##parse_string_literal(id) end_of_ident()6263 pub rule param(s: &ParserSettings) -> expr::Param = name:$(id()) expr:(_ "=" _ expr:expr(s){expr})? { expr::Param(name.into(), expr) }64 pub rule params(s: &ParserSettings) -> expr::ParamsDesc65 = params:param(s) ** comma() comma()? { expr::ParamsDesc(Rc::new(params)) }66 / { expr::ParamsDesc(Rc::new(Vec::new())) }6768 pub rule arg(s: &ParserSettings) -> (Option<IStr>, LocExpr)69 = quiet! { name:(s:$(id()) _ "=" _ {s})? expr:expr(s) {(name.map(Into::into), expr)} }70 / expected!("<argument>")7172 pub rule args(s: &ParserSettings) -> expr::ArgsDesc73 = args:arg(s)**comma() comma()? {?74 let unnamed_count = args.iter().take_while(|(n, _)| n.is_none()).count();75 let mut unnamed = Vec::with_capacity(unnamed_count);76 let mut named = Vec::with_capacity(args.len() - unnamed_count);77 let mut named_started = false;78 for (name, value) in args {79 if let Some(name) = name {80 named_started = true;81 named.push((name, value));82 } else {83 if named_started {84 return Err("<named argument>")85 }86 unnamed.push(value);87 }88 }89 Ok(expr::ArgsDesc::new(unnamed, named))90 }9192 pub rule bind(s: &ParserSettings) -> expr::BindSpec93 = name:$(id()) _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: None, value: expr}}94 / name:$(id()) _ "(" _ params:params(s) _ ")" _ "=" _ expr:expr(s) {expr::BindSpec{name:name.into(), params: Some(params), value: expr}}95 pub rule assertion(s: &ParserSettings) -> expr::AssertStmt96 = keyword("assert") _ cond:expr(s) msg:(_ ":" _ e:expr(s) {e})? { expr::AssertStmt(cond, msg) }9798 pub rule whole_line() -> &'input str99 = str:$((!['\n'][_])* "\n") {str}100 pub rule string_block() -> String101 = "|||" (!['\n']single_whitespace())* "\n"102 empty_lines:$(['\n']*)103 prefix:[' ' | '\t']+ first_line:whole_line()104 lines:("\n" {"\n"} / [' ' | '\t']*<{prefix.len()}> s:whole_line() {s})*105 [' ' | '\t']*<, {prefix.len() - 1}> "|||"106 {let mut l = empty_lines.to_owned(); l.push_str(first_line); l.extend(lines); l}107108 rule hex_char()109 = quiet! { ['0'..='9' | 'a'..='f' | 'A'..='F'] } / expected!("<hex char>")110111 rule string_char(c: rule<()>)112 = (!['\\']!c()[_])+113 / "\\\\"114 / "\\u" hex_char() hex_char() hex_char() hex_char()115 / "\\x" hex_char() hex_char()116 / ['\\'] (quiet! { ['b' | 'f' | 'n' | 'r' | 't'] / c() } / expected!("<escape character>"))117 pub rule string() -> String118 = ['"'] str:$(string_char(<"\"">)*) ['"'] {? unescape::unescape(str).ok_or("<escaped string>")}119 / ['\''] str:$(string_char(<"\'">)*) ['\''] {? unescape::unescape(str).ok_or("<escaped string>")}120 / quiet!{ "@'" str:$(("''" / (!['\''][_]))*) "'" {str.replace("''", "'")}121 / "@\"" str:$(("\"\"" / (!['"'][_]))*) "\"" {str.replace("\"\"", "\"")}122 / string_block() } / expected!("<string>")123124 pub rule field_name(s: &ParserSettings) -> expr::FieldName125 = name:$(id()) {expr::FieldName::Fixed(name.into())}126 / name:string() {expr::FieldName::Fixed(name.into())}127 / "[" _ expr:expr(s) _ "]" {expr::FieldName::Dyn(expr)}128 pub rule visibility() -> expr::Visibility129 = ":::" {expr::Visibility::Unhide}130 / "::" {expr::Visibility::Hidden}131 / ":" {expr::Visibility::Normal}132 pub rule field(s: &ParserSettings) -> expr::FieldMember133 = name:field_name(s) _ plus:"+"? _ visibility:visibility() _ value:expr(s) {expr::FieldMember{134 name,135 plus: plus.is_some(),136 params: None,137 visibility,138 value,139 }}140 / name:field_name(s) _ "(" _ params:params(s) _ ")" _ visibility:visibility() _ value:expr(s) {expr::FieldMember{141 name,142 plus: false,143 params: Some(params),144 visibility,145 value,146 }}147 pub rule obj_local(s: &ParserSettings) -> BindSpec148 = keyword("local") _ bind:bind(s) {bind}149 pub rule member(s: &ParserSettings) -> expr::Member150 = bind:obj_local(s) {expr::Member::BindStmt(bind)}151 / assertion:assertion(s) {expr::Member::AssertStmt(assertion)}152 / field:field(s) {expr::Member::Field(field)}153 pub rule objinside(s: &ParserSettings) -> expr::ObjBody154 = 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})? {155 let mut compspecs = vec![CompSpec::ForSpec(forspec)];156 compspecs.extend(others.unwrap_or_default());157 expr::ObjBody::ObjComp(expr::ObjComp{158 pre_locals,159 key,160 plus: plus.is_some(),161 value,162 post_locals,163 compspecs,164 })165 }166 / members:(member(s) ** comma()) comma()? {expr::ObjBody::MemberList(members)}167 pub rule ifspec(s: &ParserSettings) -> IfSpecData168 = keyword("if") _ expr:expr(s) {IfSpecData(expr)}169 pub rule forspec(s: &ParserSettings) -> ForSpecData170 = keyword("for") _ id:$(id()) _ keyword("in") _ cond:expr(s) {ForSpecData(id.into(), cond)}171 pub rule compspec(s: &ParserSettings) -> Vec<expr::CompSpec>172 = s:(i:ifspec(s) { expr::CompSpec::IfSpec(i) } / f:forspec(s) {expr::CompSpec::ForSpec(f)} ) ** _ {s}173 pub rule local_expr(s: &ParserSettings) -> Expr174 = keyword("local") _ binds:bind(s) ** comma() _ ";" _ expr:expr(s) { Expr::LocalExpr(binds, expr) }175 pub rule string_expr(s: &ParserSettings) -> Expr176 = s:string() {Expr::Str(s.into())}177 pub rule obj_expr(s: &ParserSettings) -> Expr178 = "{" _ body:objinside(s) _ "}" {Expr::Obj(body)}179 pub rule array_expr(s: &ParserSettings) -> Expr180 = "[" _ elems:(expr(s) ** comma()) _ comma()? "]" {Expr::Arr(elems)}181 pub rule array_comp_expr(s: &ParserSettings) -> Expr182 = "[" _ expr:expr(s) _ comma()? _ forspec:forspec(s) _ others:(others: compspec(s) _ {others})? "]" {183 let mut specs = vec![CompSpec::ForSpec(forspec)];184 specs.extend(others.unwrap_or_default());185 Expr::ArrComp(expr, specs)186 }187 pub rule number_expr(s: &ParserSettings) -> Expr188 = n:number() { expr::Expr::Num(n) }189 pub rule var_expr(s: &ParserSettings) -> Expr190 = n:$(id()) { expr::Expr::Var(n.into()) }191 pub rule id_loc(s: &ParserSettings) -> LocExpr192 = a:position!() n:$(id()) b:position!() { LocExpr(Rc::new(expr::Expr::Str(n.into())), ExprLocation(s.file_name.clone(), a,b)) }193 pub rule if_then_else_expr(s: &ParserSettings) -> Expr194 = cond:ifspec(s) _ keyword("then") _ cond_then:expr(s) cond_else:(_ keyword("else") _ e:expr(s) {e})? {Expr::IfElse{195 cond,196 cond_then,197 cond_else,198 }}199200 pub rule literal(s: &ParserSettings) -> Expr201 = v:(202 keyword("null") {LiteralType::Null}203 / keyword("true") {LiteralType::True}204 / keyword("false") {LiteralType::False}205 / keyword("self") {LiteralType::This}206 / keyword("$") {LiteralType::Dollar}207 / keyword("super") {LiteralType::Super}208 ) {Expr::Literal(v)}209210 pub rule expr_basic(s: &ParserSettings) -> Expr211 = literal(s)212213 / quiet!{"$intrinsic(" name:$(id()) ")" {Expr::Intrinsic(name.into())}}214215 / string_expr(s) / number_expr(s)216 / array_expr(s)217 / obj_expr(s)218 / array_expr(s)219 / array_comp_expr(s)220221 / keyword("importstr") _ path:string() {Expr::ImportStr(PathBuf::from(path))}222 / keyword("importbin") _ path:string() {Expr::ImportBin(PathBuf::from(path))}223 / keyword("import") _ path:string() {Expr::Import(PathBuf::from(path))}224225 / var_expr(s)226 / local_expr(s)227 / if_then_else_expr(s)228229 / keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, expr)}230 / assertion:assertion(s) _ ";" _ expr:expr(s) { Expr::AssertExpr(assertion, expr) }231232 / keyword("error") _ expr:expr(s) { Expr::ErrorStmt(expr) }233234 rule slice_part(s: &ParserSettings) -> Option<LocExpr>235 = e:(_ e:expr(s) _{e})? {e}236 pub rule slice_desc(s: &ParserSettings) -> SliceDesc237 = start:slice_part(s) ":" pair:(end:slice_part(s) step:(":" e:slice_part(s){e})? {(end, step.flatten())})? {238 let (end, step) = if let Some((end, step)) = pair {239 (end, step)240 }else{241 (None, None)242 };243244 SliceDesc { start, end, step }245 }246247 rule binop(x: rule<()>) -> ()248 = quiet!{ x() } / expected!("<binary op>")249 rule unaryop(x: rule<()>) -> ()250 = quiet!{ x() } / expected!("<unary op>")251252253 use BinaryOpType::*;254 use UnaryOpType::*;255 rule expr(s: &ParserSettings) -> LocExpr256 = precedence! {257 start:position!() v:@ end:position!() { LocExpr(Rc::new(v), ExprLocation(s.file_name.clone(), start, end)) }258 --259 a:(@) _ binop(<"||">) _ b:@ {expr_bin!(a Or b)}260 --261 a:(@) _ binop(<"&&">) _ b:@ {expr_bin!(a And b)}262 --263 a:(@) _ binop(<"|">) _ b:@ {expr_bin!(a BitOr b)}264 --265 a:@ _ binop(<"^">) _ b:(@) {expr_bin!(a BitXor b)}266 --267 a:(@) _ binop(<"&">) _ b:@ {expr_bin!(a BitAnd b)}268 --269 a:(@) _ binop(<"==">) _ b:@ {expr_bin!(a Eq b)}270 a:(@) _ binop(<"!=">) _ b:@ {expr_bin!(a Neq b)}271 --272 a:(@) _ binop(<"<">) _ b:@ {expr_bin!(a Lt b)}273 a:(@) _ binop(<">">) _ b:@ {expr_bin!(a Gt b)}274 a:(@) _ binop(<"<=">) _ b:@ {expr_bin!(a Lte b)}275 a:(@) _ binop(<">=">) _ b:@ {expr_bin!(a Gte b)}276 a:(@) _ binop(<keyword("in")>) _ b:@ {expr_bin!(a In b)}277 --278 a:(@) _ binop(<"<<">) _ b:@ {expr_bin!(a Lhs b)}279 a:(@) _ binop(<">>">) _ b:@ {expr_bin!(a Rhs b)}280 --281 a:(@) _ binop(<"+">) _ b:@ {expr_bin!(a Add b)}282 a:(@) _ binop(<"-">) _ b:@ {expr_bin!(a Sub b)}283 --284 a:(@) _ binop(<"*">) _ b:@ {expr_bin!(a Mul b)}285 a:(@) _ binop(<"/">) _ b:@ {expr_bin!(a Div b)}286 a:(@) _ binop(<"%">) _ b:@ {expr_bin!(a Mod b)}287 --288 unaryop(<"-">) _ b:@ {expr_un!(Minus b)}289 unaryop(<"!">) _ b:@ {expr_un!(Not b)}290 unaryop(<"~">) _ b:@ {expr_un!(BitNot b)}291 --292 a:(@) _ "[" _ e:slice_desc(s) _ "]" {Expr::Slice(a, e)}293 a:(@) _ "." _ a:position!() e:id_loc(s) b:position!() {Expr::Index(a, e)}294 a:(@) _ "[" _ e:expr(s) _ "]" {Expr::Index(a, e)}295 a:(@) _ "(" _ args:args(s) _ ")" ts:(_ keyword("tailstrict"))? {Expr::Apply(a, args, ts.is_some())}296 a:(@) _ "{" _ body:objinside(s) _ "}" {Expr::ObjExtend(a, body)}297 --298 e:expr_basic(s) {e}299 "(" _ e:expr(s) _ ")" {Expr::Parened(e)}300 }301302 pub rule jsonnet(s: &ParserSettings) -> LocExpr = _ e:expr(s) _ {e}303 }304}305306pub type ParseError = peg::error::ParseError<peg::str::LineCol>;307pub fn parse(str: &str, settings: &ParserSettings) -> Result<LocExpr, ParseError> {308 jsonnet_parser::jsonnet(str, settings)309}310311pub fn string_to_expr(str: IStr, settings: &ParserSettings) -> LocExpr {312 let len = str.len();313 LocExpr(314 Rc::new(Expr::Str(str)),315 ExprLocation(settings.file_name.clone(), 0, len),316 )317}318319#[cfg(test)]320pub mod tests {321 use std::path::PathBuf;322323 use BinaryOpType::*;324325 use super::{expr::*, parse};326 use crate::ParserSettings;327328 macro_rules! parse {329 ($s:expr) => {330 parse(331 $s,332 &ParserSettings {333 file_name: PathBuf::from("test.jsonnet").into(),334 },335 )336 .unwrap()337 };338 }339340 macro_rules! el {341 ($expr:expr, $from:expr, $to:expr$(,)?) => {342 LocExpr(343 std::rc::Rc::new($expr),344 ExprLocation(PathBuf::from("test.jsonnet").into(), $from, $to),345 )346 };347 }348349 #[test]350 fn multiline_string() {351 assert_eq!(352 parse!("|||\n Hello world!\n a\n|||"),353 el!(Expr::Str("Hello world!\n a\n".into()), 0, 31),354 );355 assert_eq!(356 parse!("|||\n Hello world!\n a\n|||"),357 el!(Expr::Str("Hello world!\n a\n".into()), 0, 27),358 );359 assert_eq!(360 parse!("|||\n\t\tHello world!\n\t\t\ta\n|||"),361 el!(Expr::Str("Hello world!\n\ta\n".into()), 0, 27),362 );363 assert_eq!(364 parse!("|||\n Hello world!\n a\n |||"),365 el!(Expr::Str("Hello world!\n a\n".into()), 0, 30),366 );367 }368369 #[test]370 fn slice() {371 parse!("a[1:]");372 parse!("a[1::]");373 parse!("a[:1:]");374 parse!("a[::1]");375 parse!("str[:len - 1]");376 }377378 #[test]379 fn string_escaping() {380 assert_eq!(381 parse!(r#""Hello, \"world\"!""#),382 el!(Expr::Str(r#"Hello, "world"!"#.into()), 0, 19),383 );384 assert_eq!(385 parse!(r#"'Hello \'world\'!'"#),386 el!(Expr::Str("Hello 'world'!".into()), 0, 18),387 );388 assert_eq!(parse!(r#"'\\\\'"#), el!(Expr::Str("\\\\".into()), 0, 6));389 }390391 #[test]392 fn string_unescaping() {393 assert_eq!(394 parse!(r#""Hello\nWorld""#),395 el!(Expr::Str("Hello\nWorld".into()), 0, 14),396 );397 }398399 #[test]400 fn string_verbantim() {401 assert_eq!(402 parse!(r#"@"Hello\n""World""""#),403 el!(Expr::Str("Hello\\n\"World\"".into()), 0, 19),404 );405 }406407 #[test]408 fn imports() {409 assert_eq!(410 parse!("import \"hello\""),411 el!(Expr::Import(PathBuf::from("hello")), 0, 14),412 );413 assert_eq!(414 parse!("importstr \"garnish.txt\""),415 el!(Expr::ImportStr(PathBuf::from("garnish.txt")), 0, 23)416 );417 }418419 #[test]420 fn empty_object() {421 assert_eq!(422 parse!("{}"),423 el!(Expr::Obj(ObjBody::MemberList(vec![])), 0, 2)424 );425 }426427 #[test]428 fn basic_math() {429 assert_eq!(430 parse!("2+2*2"),431 el!(432 Expr::BinaryOp(433 el!(Expr::Num(2.0), 0, 1),434 Add,435 el!(436 Expr::BinaryOp(el!(Expr::Num(2.0), 2, 3), Mul, el!(Expr::Num(2.0), 4, 5)),437 2,438 5439 )440 ),441 0,442 5443 )444 );445 }446447 #[test]448 fn basic_math_with_indents() {449 assert_eq!(450 parse!("2 + 2 * 2 "),451 el!(452 Expr::BinaryOp(453 el!(Expr::Num(2.0), 0, 1),454 Add,455 el!(456 Expr::BinaryOp(el!(Expr::Num(2.0), 7, 8), Mul, el!(Expr::Num(2.0), 13, 14),),457 7,458 14459 ),460 ),461 0,462 14463 )464 );465 }466467 #[test]468 fn basic_math_parened() {469 assert_eq!(470 parse!("2+(2+2*2)"),471 el!(472 Expr::BinaryOp(473 el!(Expr::Num(2.0), 0, 1),474 Add,475 el!(476 Expr::Parened(el!(477 Expr::BinaryOp(478 el!(Expr::Num(2.0), 3, 4),479 Add,480 el!(481 Expr::BinaryOp(482 el!(Expr::Num(2.0), 5, 6),483 Mul,484 el!(Expr::Num(2.0), 7, 8),485 ),486 5,487 8488 ),489 ),490 3,491 8492 )),493 2,494 9495 ),496 ),497 0,498 9499 )500 );501 }502503 504 #[test]505 fn comments() {506 assert_eq!(507 parse!("2//comment\n+//comment\n3/*test*/*/*test*/4"),508 el!(509 Expr::BinaryOp(510 el!(Expr::Num(2.0), 0, 1),511 Add,512 el!(513 Expr::BinaryOp(514 el!(Expr::Num(3.0), 22, 23),515 Mul,516 el!(Expr::Num(4.0), 40, 41)517 ),518 22,519 41520 )521 ),522 0,523 41524 )525 );526 }527528 529 #[test]530 fn comment_escaping() {531 assert_eq!(532 parse!("2/*\\*/+*/ - 22"),533 el!(534 Expr::BinaryOp(el!(Expr::Num(2.0), 0, 1), Sub, el!(Expr::Num(22.0), 12, 14)),535 0,536 14537 )538 );539 }540541 #[test]542 fn suffix() {543 544 545 546 547 }548549 #[test]550 fn array_comp() {551 use Expr::*;552 553554555556 assert_eq!(557 parse!("[std.deepJoin(x) for x in arr]"),558 el!(559 ArrComp(560 el!(561 Apply(562 el!(563 Index(564 el!(Var("std".into()), 1, 4),565 el!(Str("deepJoin".into()), 5, 13)566 ),567 1,568 13569 ),570 ArgsDesc::new(vec![el!(Var("x".into()), 14, 15)], vec![]),571 false,572 ),573 1,574 16575 ),576 vec![CompSpec::ForSpec(ForSpecData(577 "x".into(),578 el!(Var("arr".into()), 26, 29)579 ))]580 ),581 0,582 30583 ),584 )585 }586587 #[test]588 fn reserved() {589 use Expr::*;590 assert_eq!(parse!("null"), el!(Literal(LiteralType::Null), 0, 4));591 assert_eq!(parse!("nulla"), el!(Var("nulla".into()), 0, 5));592 }593594 #[test]595 fn multiple_args_buf() {596 parse!("a(b, null_fields)");597 }598599 #[test]600 fn infix_precedence() {601 use Expr::*;602 assert_eq!(603 parse!("!a && !b"),604 el!(605 BinaryOp(606 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),607 And,608 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 7, 8)), 6, 8)609 ),610 0,611 8612 )613 );614 }615616 #[test]617 fn infix_precedence_division() {618 use Expr::*;619 assert_eq!(620 parse!("!a / !b"),621 el!(622 BinaryOp(623 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 1, 2)), 0, 2),624 Div,625 el!(UnaryOp(UnaryOpType::Not, el!(Var("b".into()), 6, 7)), 5, 7)626 ),627 0,628 7629 )630 );631 }632633 #[test]634 fn double_negation() {635 use Expr::*;636 assert_eq!(637 parse!("!!a"),638 el!(639 UnaryOp(640 UnaryOpType::Not,641 el!(UnaryOp(UnaryOpType::Not, el!(Var("a".into()), 2, 3)), 1, 3)642 ),643 0,644 3645 )646 )647 }648649 #[test]650 fn array_test_error() {651 parse!("[a for a in b if c for e in f]");652 653 }654655 #[test]656 fn missing_newline_between_comment_and_eof() {657 parse!(658 "{a:1}659660 //+213"661 );662 }663664 #[test]665 fn default_param_before_nondefault() {666 parse!("local x(foo = 'foo', bar) = null; null");667 }668669 #[test]670 fn can_parse_stdlib() {671 parse!(jrsonnet_stdlib::STDLIB_STR);672 }673674 #[test]675 fn add_location_info_to_all_sub_expressions() {676 use Expr::*;677678 let file_name: std::rc::Rc<std::path::Path> = PathBuf::from("test.jsonnet").into();679 let expr = parse(680 "{} { local x = 1, x: x } + {}",681 &ParserSettings {682 file_name: file_name.clone(),683 },684 )685 .unwrap();686 assert_eq!(687 expr,688 el!(689 BinaryOp(690 el!(691 ObjExtend(692 el!(Obj(ObjBody::MemberList(vec![])), 0, 2),693 ObjBody::MemberList(vec![694 Member::BindStmt(BindSpec {695 name: "x".into(),696 params: None,697 value: el!(Num(1.0), 15, 16)698 }),699 Member::Field(FieldMember {700 name: FieldName::Fixed("x".into()),701 plus: false,702 params: None,703 visibility: Visibility::Normal,704 value: el!(Var("x".into()), 21, 22),705 })706 ])707 ),708 0,709 24710 ),711 BinaryOpType::Add,712 el!(Obj(ObjBody::MemberList(vec![])), 27, 29),713 ),714 0,715 29716 ),717 );718 }719 720 721722723724725726}