1use std::rc::Rc;23use jrsonnet_gcmodule::Acyclic;4use jrsonnet_ir::{5 ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,6 ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,7 ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,8 Source, Span, Spanned, UnaryOpType, Visibility, unescape,9};10use jrsonnet_lexer::{Lexeme, Lexer, Span as LexSpan, SyntaxKind, T, collect_lexed_str_block};1112pub struct ParserSettings {13 pub source: Source,14}1516#[derive(Debug, Clone)]17pub struct ParseError {18 pub message: String,19 pub location: LexSpan,20}2122impl std::fmt::Display for ParseError {23 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {24 write!(f, "{}", self.message)25 }26}2728type Result<T> = std::result::Result<T, ParseError>;2930struct Parser<'a> {31 lexemes: Vec<Lexeme<'a>>,32 offset: usize,33 source: Source,34}3536impl<'a> Parser<'a> {37 fn new(code: &'a str, source: Source) -> Self {38 Self {39 lexemes: Lexer::new(code)40 .filter(|l| {41 !matches!(42 l.kind,43 SyntaxKind::WHITESPACE44 | SyntaxKind::SINGLE_LINE_SLASH_COMMENT45 | SyntaxKind::SINGLE_LINE_HASH_COMMENT46 | SyntaxKind::MULTI_LINE_COMMENT47 )48 })49 .collect(),50 offset: 0,51 source,52 }53 }5455 fn peek(&self) -> SyntaxKind {56 if self.at_eof() {57 SyntaxKind::EOF58 } else {59 self.lexemes[self.offset].kind60 }61 }6263 fn text(&self) -> &'a str {64 self.lexemes[self.offset].text65 }6667 fn at(&self, kind: SyntaxKind) -> bool {68 !self.at_eof() && self.peek() == kind69 }7071 fn eat_any(&mut self) {72 self.offset += 1;73 }7475 fn at_eof(&self) -> bool {76 self.offset >= self.lexemes.len()77 }7879 fn try_eat(&mut self, t: SyntaxKind) -> bool {80 if self.at(t) {81 self.eat_any();82 return true;83 }84 false85 }8687 fn current_desc(&self) -> String {88 if self.at_eof() {89 return "end of file".to_owned();90 }91 let kind = self.peek();92 let text = self.text();93 let name = kind.display_name();94 if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {95 format!("{name} \"{text}\"")96 } else {97 name.to_owned()98 }99 }100101 fn eat(&mut self, t: SyntaxKind) -> Result<()> {102 if !self.at(t) {103 return Err(self.error(format!(104 "expected {}, got {}",105 t.display_name(),106 self.current_desc(),107 )));108 }109 self.eat_any();110 Ok(())111 }112113 fn span_start(&self) -> u32 {114 if self.at_eof() {115 if let Some(last) = self.lexemes.last() {116 return last.range.1;117 }118 return 0;119 }120 self.lexemes[self.offset].range.0121 }122123 fn span_end(&self) -> u32 {124 self.lexemes[self.offset - 1].range.1125 }126127 fn error(&self, message: String) -> ParseError {128 ParseError {129 location: self.lexemes[self.offset].range,130 message,131 }132 }133}134135fn spanned<T: Acyclic>(136 p: &mut Parser<'_>,137 cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,138) -> Result<Spanned<T>> {139 let start = p.span_start();140 let v = cb(p)?;141 let end = p.span_end();142 Ok(Spanned::new(v, Span(p.source.clone(), start, end)))143}144145fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {146 let kind = p.peek();147 let text = p.text();148 let s = match kind {149 SyntaxKind::STRING_DOUBLE => {150 let inner = &text[1..text.len() - 1];151 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?152 }153 SyntaxKind::STRING_SINGLE => {154 let inner = &text[1..text.len() - 1];155 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?156 }157 SyntaxKind::STRING_DOUBLE_VERBATIM => {158 let inner = &text[2..text.len() - 1];159 inner.replace("\"\"", "\"")160 }161 SyntaxKind::STRING_SINGLE_VERBATIM => {162 let inner = &text[2..text.len() - 1];163 inner.replace("''", "'")164 }165 SyntaxKind::STRING_BLOCK => {166 let inner = &text[3..];167 let collected = collect_lexed_str_block(inner)168 .map_err(|_| p.error("invalid string block".into()))?;169 let mut result = String::new();170 for (i, line) in collected.lines.iter().enumerate() {171 if i > 0 {172 result.push('\n');173 }174 result.push_str(line);175 }176 if !collected.truncate {177 result.push('\n');178 }179 result180 }181 _ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),182 };183 p.eat_any();184 Ok(s.into())185}186187fn is_string_token(kind: SyntaxKind) -> bool {188 matches!(189 kind,190 SyntaxKind::STRING_DOUBLE191 | SyntaxKind::STRING_SINGLE192 | SyntaxKind::STRING_DOUBLE_VERBATIM193 | SyntaxKind::STRING_SINGLE_VERBATIM194 | SyntaxKind::STRING_BLOCK195 )196}197198fn parse_number(p: &mut Parser<'_>) -> Result<f64> {199 let text = p.text();200 let n: f64 = text201 .replace('_', "")202 .parse()203 .map_err(|_| p.error(format!("invalid number literal: {text}")))?;204 if !n.is_finite() {205 return Err(p.error("numbers are finite".into()));206 }207 p.eat_any();208 Ok(n)209}210211fn ident(p: &mut Parser<'_>) -> Result<IStr> {212 let text = p.text();213 p.eat(SyntaxKind::IDENT)?;214 Ok(IStr::from(text))215}216217fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {218 let t = match p.peek() {219 T![self] => LiteralType::This,220 T![super] => LiteralType::Super,221 T!['$'] => LiteralType::Dollar,222 T![null] => LiteralType::Null,223 T![true] => LiteralType::True,224 T![false] => LiteralType::False,225 _ => return None,226 };227 p.eat_any();228 Some(t)229}230231fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {232 p.eat(T![assert])?;233 let cond = spanned(p, expr)?;234 let msg = if p.try_eat(T![:]) {235 Some(spanned(p, expr)?)236 } else {237 None238 };239 Ok(AssertStmt(cond, msg))240}241242fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {243 let v = spanned(p, |p| p.eat(T![if]))?;244 let cond = expr(p)?;245 Ok(IfSpecData { span: v.span, cond })246}247248fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {249 let cond = if_spec_data(p)?;250 p.eat(T![then])?;251 let cond_then = expr(p)?;252 let cond_else = if p.try_eat(T![else]) {253 Some(expr(p)?)254 } else {255 None256 };257 Ok(IfElse {258 cond,259 cond_then,260 cond_else,261 })262}263264fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {265 p.eat(T![:])?;266 let end = if !p.at(T![:]) && !p.at(T![']']) {267 Some(spanned(p, expr)?)268 } else {269 None270 };271 let step = if p.try_eat(T![:]) {272 if p.at(T![']']) {273 None274 } else {275 Some(spanned(p, expr)?)276 }277 } else {278 None279 };280 Ok(SliceDesc { start, end, step })281}282283fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {284 if p.at(SyntaxKind::IDENT) {285 return Ok(Destruct::Full(ident(p)?));286 }287 #[cfg(not(feature = "exp-destruct"))]288 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));289 #[cfg(feature = "exp-destruct")]290 {291 if p.try_eat(T![?]) {292 return Ok(Destruct::Skip);293 }294 if p.at(T!['[']) {295 return destruct_array(p);296 }297 if p.at(T!['{']) {298 return destruct_object(p);299 }300 Err(p.error(format!(301 "expected destructure pattern, got {}",302 p.current_desc()303 )))304 }305}306307#[cfg(feature = "exp-destruct")]308fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {309 p.eat(T![...])?;310 if p.at(SyntaxKind::IDENT) {311 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))312 } else {313 Ok(jrsonnet_ir::DestructRest::Drop)314 }315}316317#[cfg(feature = "exp-destruct")]318fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {319 p.eat(T!['['])?;320 let mut start = Vec::new();321 let mut rest = None;322 let mut end = Vec::new();323 if !p.at(T![']']) {324 loop {325 if p.at(T![...]) {326 rest = Some(destruct_rest(p)?);327 if p.try_eat(T![,]) {328 if !p.at(T![']']) {329 loop {330 end.push(destruct(p)?);331 if !p.try_eat(T![,]) {332 break;333 }334 if p.at(T![']']) {335 break;336 }337 }338 }339 }340 break;341 }342 start.push(destruct(p)?);343 if !p.try_eat(T![,]) {344 break;345 }346 if p.at(T![']']) {347 break;348 }349 }350 }351 p.eat(T![']'])?;352 Ok(Destruct::Array { start, rest, end })353}354355#[cfg(feature = "exp-destruct")]356fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {357 p.eat(T!['{'])?;358 let mut fields = Vec::new();359 let mut rest = None;360 if !p.at(T!['}']) {361 loop {362 if p.at(T![...]) {363 rest = Some(destruct_rest(p)?);364 p.try_eat(T![,]);365 break;366 }367 let name = ident(p)?;368 let into = if p.try_eat(T![:]) {369 Some(destruct(p)?)370 } else {371 None372 };373 let default = if p.try_eat(T![=]) {374 Some(Rc::new(spanned(p, expr)?))375 } else {376 None377 };378 fields.push((name, into, default));379 if !p.try_eat(T![,]) {380 break;381 }382 if p.at(T!['}']) {383 break;384 }385 }386 }387 p.eat(T!['}'])?;388 Ok(Destruct::Object { fields, rest })389}390391fn params(p: &mut Parser<'_>) -> Result<ExprParams> {392 if p.at(T![')']) {393 return Ok(ExprParams::new(Vec::new()));394 }395 let mut result = Vec::new();396 loop {397 let d = destruct(p)?;398 let default = if p.try_eat(T![=]) {399 Some(Rc::new(expr(p)?))400 } else {401 None402 };403 result.push(ExprParam {404 destruct: d,405 default,406 });407 if !p.try_eat(T![,]) {408 break;409 }410 if p.at(T![')']) {411 break;412 }413 }414 Ok(ExprParams::new(result))415}416417fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {418 if p.at(T![')']) {419 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));420 }421 let mut unnamed = Vec::new();422 let mut names = Vec::new();423 let mut values = Vec::new();424 let mut named_started = false;425 loop {426 let is_named = p.at(SyntaxKind::IDENT) && {427 let next_offset = p.offset + 1;428 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]429 };430 if is_named {431 let name: IStr = ident(p)?;432 p.eat(T![=])?;433 let value = Rc::new(expr(p)?);434435 names.push(name);436 values.push(value);437 named_started = true;438 } else {439 if named_started {440 return Err(p.error("positional argument after named argument".into()));441 }442 unnamed.push(Rc::new(expr(p)?));443 }444 if !p.try_eat(T![,]) {445 break;446 }447 if p.at(T![')']) {448 break;449 }450 }451 Ok(ArgsDesc::new(unnamed, names, values))452}453454fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {455 #[cfg(feature = "exp-destruct")]456 {457 if !p.at(SyntaxKind::IDENT) {458 let d = destruct(p)?;459 p.eat(T![=])?;460 let value = Rc::new(expr(p)?);461 return Ok(BindSpec::Field { into: d, value });462 }463 }464 let name = ident(p)?;465 if p.try_eat(T!['(']) {466 let ps = params(p)?;467 p.eat(T![')'])?;468 p.eat(T![=])?;469 let value = Rc::new(expr(p)?);470 Ok(BindSpec::Function {471 name,472 params: ps,473 value,474 })475 } else {476 p.eat(T![=])?;477 let value = Rc::new(expr(p)?);478 Ok(BindSpec::Field {479 into: Destruct::Full(name),480 value,481 })482 }483}484485fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {486 p.eat(T![:])?;487 if p.try_eat(T![:]) {488 if p.try_eat(T![:]) {489 Ok(Visibility::Unhide)490 } else {491 Ok(Visibility::Hidden)492 }493 } else {494 Ok(Visibility::Normal)495 }496}497498fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {499 if p.at(SyntaxKind::IDENT) {500 Ok(FieldName::Fixed(ident(p)?))501 } else if is_string_token(p.peek()) {502 Ok(FieldName::Fixed(parse_string_content(p)?))503 } else if p.at(T!['[']) {504 p.eat(T!['['])?;505 let e = expr(p)?;506 p.eat(T![']'])?;507 Ok(FieldName::Dyn(e))508 } else {509 Err(p.error(format!("expected field name, got {}", p.current_desc())))510 }511}512513fn field(p: &mut Parser<'_>) -> Result<FieldMember> {514 let name = spanned(p, field_name)?;515516 if p.at(T!['(']) {517 p.eat(T!['('])?;518 let ps = params(p)?;519 p.eat(T![')'])?;520 let vis = visibility(p)?;521 let value = Rc::new(expr(p)?);522 Ok(FieldMember {523 name,524 plus: false,525 params: Some(ps),526 visibility: vis,527 value,528 })529 } else {530 let plus = p.try_eat(T![+]);531 let vis = visibility(p)?;532 let value = Rc::new(expr(p)?);533 Ok(FieldMember {534 name,535 plus,536 params: None,537 visibility: vis,538 value,539 })540 }541}542543fn member(p: &mut Parser<'_>) -> Result<Member> {544 if p.at(T![local]) {545 p.eat(T![local])?;546 Ok(Member::BindStmt(bind(p)?))547 } else if p.at(T![assert]) {548 Ok(Member::AssertStmt(assert_stmt(p)?))549 } else {550 Ok(Member::Field(field(p)?))551 }552}553554fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {555 p.eat(T![for])?;556 let d = destruct(p)?;557 p.eat(T![in])?;558 let over = expr(p)?;559 Ok(ForSpecData { destruct: d, over })560}561562fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {563 let mut specs = Vec::new();564 specs.push(CompSpec::ForSpec(for_spec(p)?));565 loop {566 if p.at(T![for]) {567 specs.push(CompSpec::ForSpec(for_spec(p)?));568 } else if p.at(T![if]) {569 let isd = if_spec_data(p)?;570 specs.push(CompSpec::IfSpec(isd));571 } else {572 break;573 }574 }575 Ok(specs)576}577578fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {579 if p.at(T!['}']) {580 return Ok(ObjBody::MemberList(ObjMembers {581 locals: Rc::new(Vec::new()),582 asserts: Rc::new(Vec::new()),583 fields: Vec::new(),584 }));585 }586587 let mut members = Vec::new();588 loop {589 members.push(member(p)?);590 if !p.try_eat(T![,]) {591 break;592 }593 if p.at(T!['}']) || p.at(T![for]) {594 break;595 }596 }597598 if p.at(T![for]) {599 let specs = compspecs(p)?;600 let mut locals = Vec::new();601 let mut field_member = None;602 for m in members {603 match m {604 Member::Field(f) => {605 if field_member.is_some() {606 return Err(607 p.error("object comprehension can only contain one field".into())608 );609 }610 field_member = Some(f);611 }612 Member::BindStmt(b) => locals.push(b),613 Member::AssertStmt(_) => {614 return Err(p.error("asserts are unsupported in object comprehension".into()));615 }616 }617 }618 Ok(ObjBody::ObjComp(ObjComp {619 locals: Rc::new(locals),620 field: Rc::new(621 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,622 ),623 compspecs: specs,624 }))625 } else {626 let mut locals = Vec::new();627 let mut asserts = Vec::new();628 let mut fields = Vec::new();629 for m in members {630 match m {631 Member::Field(f) => fields.push(f),632 Member::BindStmt(b) => locals.push(b),633 Member::AssertStmt(a) => asserts.push(a),634 }635 }636 Ok(ObjBody::MemberList(ObjMembers {637 locals: Rc::new(locals),638 asserts: Rc::new(asserts),639 fields,640 }))641 }642}643644#[allow(clippy::too_many_lines)]645fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {646 if let Some(lit) = literal(p) {647 return Ok(Expr::Literal(lit));648 }649650 match p.peek() {651 SyntaxKind::STRING_DOUBLE652 | SyntaxKind::STRING_SINGLE653 | SyntaxKind::STRING_DOUBLE_VERBATIM654 | SyntaxKind::STRING_SINGLE_VERBATIM655 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),656657 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),658659 T!['('] => {660 p.eat(T!['('])?;661 let e = expr(p)?;662 p.eat(T![')'])?;663 Ok(e)664 }665666 T!['['] => {667 p.eat(T!['['])?;668 if p.at(T![']']) {669 p.eat(T![']'])?;670 return Ok(Expr::Arr(Rc::new(Vec::new())));671 }672 let first = expr(p)?;673 if p.at(T![for]) {674 let specs = compspecs(p)?;675 p.eat(T![']'])?;676 Ok(Expr::ArrComp(Rc::new(first), specs))677 } else if p.at(T![,]) && {678 let next = p.offset + 1;679 next < p.lexemes.len() && p.lexemes[next].kind == T![for]680 } {681 p.eat(T![,])?;682 let specs = compspecs(p)?;683 p.eat(T![']'])?;684 Ok(Expr::ArrComp(Rc::new(first), specs))685 } else {686 let mut elems = vec![first];687 while p.try_eat(T![,]) {688 if p.at(T![']']) {689 break;690 }691 elems.push(expr(p)?);692 }693 p.eat(T![']'])?;694 Ok(Expr::Arr(Rc::new(elems)))695 }696 }697698 T!['{'] => {699 p.eat(T!['{'])?;700 let body = objinside(p)?;701 p.eat(T!['}'])?;702 Ok(Expr::Obj(body))703 }704705 T![local] => {706 p.eat(T![local])?;707 let mut binds = Vec::new();708 loop {709 binds.push(bind(p)?);710 if !p.try_eat(T![,]) {711 break;712 }713 }714 p.eat(T![;])?;715 let body = expr(p)?;716 Ok(Expr::LocalExpr(binds, Box::new(body)))717 }718719 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),720721 T![function] => {722 p.eat(T![function])?;723 p.eat(T!['('])?;724 let ps = params(p)?;725 p.eat(T![')'])?;726 let body = expr(p)?;727 Ok(Expr::Function(ps, Rc::new(body)))728 }729730 T![assert] => {731 let a = assert_stmt(p)?;732 p.eat(T![;])?;733 let rest = expr(p)?;734 Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))735 }736737 T![error] => {738 let span = spanned(p, |p| p.eat(T![error]))?;739 let e = expr(p)?;740 Ok(Expr::ErrorStmt(span.span, Box::new(e)))741 }742743 T![importstr] => {744 let kind = spanned(p, |p| {745 p.eat(T![importstr])?;746 Ok(ImportKind::Str)747 })?;748 let path = expr(p)?;749 Ok(Expr::Import(kind, Box::new(path)))750 }751752 T![importbin] => {753 let kind = spanned(p, |p| {754 p.eat(T![importbin])?;755 Ok(ImportKind::Bin)756 })?;757 let path = expr(p)?;758 Ok(Expr::Import(kind, Box::new(path)))759 }760761 T![import] => {762 let kind = spanned(p, |p| {763 p.eat(T![import])?;764 Ok(ImportKind::Normal)765 })?;766 let path = expr(p)?;767 Ok(Expr::Import(kind, Box::new(path)))768 }769770 SyntaxKind::IDENT => {771 let n = spanned(p, |p| {772 let s: IStr = p.text().into();773 p.eat_any();774 Ok(s)775 })?;776 Ok(Expr::Var(n))777 }778779 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),780 }781}782783fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {784 if parts.is_empty() {785 return;786 }787 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));788 *e = Expr::Index {789 indexable: Box::new(old),790 parts: std::mem::take(parts),791 };792}793794fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {795 let mut e = expr_basic(p)?;796 797 798 799 let mut parts: Vec<IndexPart> = Vec::new();800801 loop {802 #[cfg(feature = "exp-null-coaelse")]803 if p.at(T![?]) {804 p.eat_any();805 if p.try_eat(T![.]) {806 if p.at(T!['[']) {807 808 p.eat(T!['['])?;809 let idx = spanned(p, expr)?;810 p.eat(T![']'])?;811 parts.push(IndexPart {812 span: idx.span,813 value: idx.value,814 null_coaelse: true,815 });816 } else {817 818 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;819 parts.push(IndexPart {820 span: id_spanned.span,821 value: id_spanned.value,822 null_coaelse: true,823 });824 }825 } else {826 return Err(p.error("expected '.' after '?'".into()));827 }828 continue;829 }830831 if p.at(T![.]) {832 p.eat(T![.])?;833 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;834 parts.push(IndexPart {835 span: id_spanned.span,836 value: id_spanned.value,837 #[cfg(feature = "exp-null-coaelse")]838 null_coaelse: false,839 });840 } else if p.at(T!['[']) {841 p.eat(T!['['])?;842843 if p.at(T![:]) {844 845 flush_index_parts(&mut e, &mut parts);846 let slice = slice_desc(p, None)?;847 p.eat(T![']'])?;848 e = Expr::Slice(Box::new(Slice { value: e, slice }));849 } else {850 let idx = spanned(p, expr)?;851 if p.at(T![:]) {852 853 flush_index_parts(&mut e, &mut parts);854 let slice = slice_desc(p, Some(idx))?;855 p.eat(T![']'])?;856 e = Expr::Slice(Box::new(Slice { value: e, slice }));857 } else {858 859 p.eat(T![']'])?;860 parts.push(IndexPart {861 span: idx.span,862 value: idx.value,863 #[cfg(feature = "exp-null-coaelse")]864 null_coaelse: false,865 });866 }867 }868 } else if p.at(T!['(']) {869 flush_index_parts(&mut e, &mut parts);870 let args_spanned = spanned(p, |p| {871 p.eat(T!['('])?;872 let a = args(p)?;873 p.eat(T![')'])?;874 Ok(a)875 })?;876 let tailstrict = p.try_eat(T![tailstrict]);877 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);878 } else if p.at(T!['{']) {879 flush_index_parts(&mut e, &mut parts);880 p.eat(T!['{'])?;881 let body = objinside(p)?;882 p.eat(T!['}'])?;883 e = Expr::ObjExtend(Rc::new(e), body);884 } else {885 break;886 }887 }888889 flush_index_parts(&mut e, &mut parts);890 Ok(e)891}892893fn prefix_binding_power(op: UnaryOpType) -> u8 {894 match op {895 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,896 }897}898899fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {900 match op {901 BinaryOpType::Or => (2, 3),902 #[cfg(feature = "exp-null-coaelse")]903 BinaryOpType::NullCoaelse => (2, 3),904 BinaryOpType::And => (4, 5),905 BinaryOpType::BitOr => (6, 7),906 BinaryOpType::BitXor => (8, 9),907 BinaryOpType::BitAnd => (10, 11),908 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),909 BinaryOpType::Lt910 | BinaryOpType::Gt911 | BinaryOpType::Lte912 | BinaryOpType::Gte913 | BinaryOpType::In => (14, 15),914 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),915 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),916 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),917 }918}919920fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {921 match kind {922 T![+] => Some(UnaryOpType::Plus),923 T![-] => Some(UnaryOpType::Minus),924 T![!] => Some(UnaryOpType::Not),925 T![~] => Some(UnaryOpType::BitNot),926 _ => None,927 }928}929930fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {931 match p.peek() {932 T![||] => Some(BinaryOpType::Or),933 T![&&] => Some(BinaryOpType::And),934 T![|] => Some(BinaryOpType::BitOr),935 T![^] => Some(BinaryOpType::BitXor),936 T![&] => Some(BinaryOpType::BitAnd),937 T![==] => Some(BinaryOpType::Eq),938 T![!=] => Some(BinaryOpType::Neq),939 T![<] => Some(BinaryOpType::Lt),940 T![>] => Some(BinaryOpType::Gt),941 T![<=] => Some(BinaryOpType::Lte),942 T![>=] => Some(BinaryOpType::Gte),943 T![<<] => Some(BinaryOpType::Lhs),944 T![>>] => Some(BinaryOpType::Rhs),945 T![+] => Some(BinaryOpType::Add),946 T![-] => Some(BinaryOpType::Sub),947 T![*] => Some(BinaryOpType::Mul),948 T![/] => Some(BinaryOpType::Div),949 T![%] => Some(BinaryOpType::Mod),950 T![in] => Some(BinaryOpType::In),951 #[cfg(feature = "exp-null-coaelse")]952 T![??] => Some(BinaryOpType::NullCoaelse),953 _ => None,954 }955}956957fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {958 let mut lhs = if let Some(op) = unary_op(p.peek()) {959 p.eat_any();960 let rbp = prefix_binding_power(op);961 let rhs = expr_bp(p, rbp)?;962 Expr::UnaryOp(op, Box::new(rhs))963 } else {964 expr_suffix(p)?965 };966967 loop {968 if p.at_eof() {969 break;970 }971972 let Some(op) = binary_op(p) else {973 break;974 };975976 let (lbp, rbp) = infix_binding_power(op);977 if lbp < min_bp {978 break;979 }980981 p.eat_any();982 let rhs = expr_bp(p, rbp)?;983 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));984 }985986 Ok(lhs)987}988989fn expr(p: &mut Parser<'_>) -> Result<Expr> {990 expr_bp(p, 0)991}992993pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {994 let mut p = Parser::new(str, settings.source.clone());995 for lexeme in &p.lexemes {996 if let Some(desc) = lexeme.kind.error_description() {997 return Err(ParseError {998 message: desc.to_owned(),999 location: lexeme.range,1000 });1001 }1002 }1003 let e = expr(&mut p)?;1004 if !p.at_eof() {1005 return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1006 }1007 Ok(e)1008}10091010pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1011 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10121013 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1014}10151016#[cfg(test)]1017mod tests {1018 use std::fs;10191020 use insta::{assert_snapshot, glob};1021 use jrsonnet_ir::{IStr, Source};10221023 use super::*;10241025 fn parse_str(input: &str) -> Expr {1026 let source = Source::new_virtual("<test>".into(), input.into());1027 let settings = ParserSettings { source };1028 parse(input, &settings).unwrap()1029 }10301031 #[test]1032 #[cfg(not(feature = "exp-null-coaelse"))]1033 fn basic_test() {1034 let v = parse_str("assert true[false] : false ; true");1035 assert_snapshot!(format!("{v:#?}"));1036 }10371038 #[test]1039 fn literals() {1040 let v = parse_str("[null, true, false, self, super, $]");1041 assert_snapshot!(format!("{v:#?}"));1042 }10431044 #[test]1045 fn basic_math() {1046 let v = parse_str("2+2*2");1047 assert_snapshot!(format!("{v:#?}"));1048 }10491050 #[test]1051 fn underscore_numbers() {1052 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1053 assert_snapshot!(format!("{v:#?}"));1054 }10551056 #[test]1057 fn strings() {1058 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1059 assert_snapshot!(format!("{v:#?}"));1060 }10611062 #[test]1063 fn object() {1064 let v = parse_str("{a: 1, b:: 2, c::: 3}");1065 assert_snapshot!(format!("{v:#?}"));1066 }10671068 #[test]1069 fn function_and_call() {1070 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1071 assert_snapshot!(format!("{v:#?}"));1072 }10731074 #[test]1075 fn if_then_else() {1076 let v = parse_str("if true then 1 else 2");1077 assert_snapshot!(format!("{v:#?}"));1078 }10791080 #[test]1081 fn imports() {1082 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1083 assert_snapshot!(format!("{v:#?}"));1084 }10851086 #[test]1087 fn array_comp() {1088 let v = parse_str("[x for x in arr]");1089 assert_snapshot!(format!("{v:#?}"));1090 }10911092 #[test]1093 #[cfg(not(feature = "exp-null-coaelse"))]1094 fn index_and_suffix() {1095 let v = parse_str("std.test(2).field[0]");1096 assert_snapshot!(format!("{v:#?}"));1097 }10981099 #[test]1100 fn obj_extend() {1101 let v = parse_str("{} { x: 1 }");1102 assert_snapshot!(format!("{v:#?}"));1103 }11041105 #[test]1106 fn unary_ops() {1107 let v = parse_str("!a && !b");1108 assert_snapshot!(format!("{v:#?}"));1109 }11101111 #[test]1112 fn error_expr() {1113 let v = parse_str("error \"bad\"");1114 assert_snapshot!(format!("{v:#?}"));1115 }11161117 #[test]1118 fn slice() {1119 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1120 assert_snapshot!(format!("{v:#?}"));1121 }11221123 #[test]1124 #[cfg(not(feature = "exp-null-coaelse"))]1125 fn peg_snapshots() {1126 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1127 let input = fs::read_to_string(path).expect("read test file");1128 let source = Source::new_virtual("<test>".into(), IStr::empty());1129 let settings = ParserSettings { source };1130 let v = parse(&input, &settings).unwrap();1131 let v = format!("{v:#?}");1132 assert_snapshot!(v);1133 });1134 }1135}