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()));420 }421 let mut unnamed = Vec::new();422 let mut named = Vec::new();423 let mut named_started = false;424 loop {425 let is_named = p.at(SyntaxKind::IDENT) && {426 let next_offset = p.offset + 1;427 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]428 };429 if is_named {430 let name: IStr = ident(p)?;431 p.eat(T![=])?;432 let value = Rc::new(expr(p)?);433 named.push((name, value));434 named_started = true;435 } else {436 if named_started {437 return Err(p.error("positional argument after named argument".into()));438 }439 unnamed.push(Rc::new(expr(p)?));440 }441 if !p.try_eat(T![,]) {442 break;443 }444 if p.at(T![')']) {445 break;446 }447 }448 Ok(ArgsDesc::new(unnamed, named))449}450451fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {452 #[cfg(feature = "exp-destruct")]453 {454 if !p.at(SyntaxKind::IDENT) {455 let d = destruct(p)?;456 p.eat(T![=])?;457 let value = Rc::new(expr(p)?);458 return Ok(BindSpec::Field { into: d, value });459 }460 }461 let name = ident(p)?;462 if p.try_eat(T!['(']) {463 let ps = params(p)?;464 p.eat(T![')'])?;465 p.eat(T![=])?;466 let value = Rc::new(expr(p)?);467 Ok(BindSpec::Function {468 name,469 params: ps,470 value,471 })472 } else {473 p.eat(T![=])?;474 let value = Rc::new(expr(p)?);475 Ok(BindSpec::Field {476 into: Destruct::Full(name),477 value,478 })479 }480}481482fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {483 p.eat(T![:])?;484 if p.try_eat(T![:]) {485 if p.try_eat(T![:]) {486 Ok(Visibility::Unhide)487 } else {488 Ok(Visibility::Hidden)489 }490 } else {491 Ok(Visibility::Normal)492 }493}494495fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {496 if p.at(SyntaxKind::IDENT) {497 Ok(FieldName::Fixed(ident(p)?))498 } else if is_string_token(p.peek()) {499 Ok(FieldName::Fixed(parse_string_content(p)?))500 } else if p.at(T!['[']) {501 p.eat(T!['['])?;502 let e = expr(p)?;503 p.eat(T![']'])?;504 Ok(FieldName::Dyn(e))505 } else {506 Err(p.error(format!("expected field name, got {}", p.current_desc())))507 }508}509510fn field(p: &mut Parser<'_>) -> Result<FieldMember> {511 let name = spanned(p, field_name)?;512513 if p.at(T!['(']) {514 p.eat(T!['('])?;515 let ps = params(p)?;516 p.eat(T![')'])?;517 let vis = visibility(p)?;518 let value = Rc::new(expr(p)?);519 Ok(FieldMember {520 name,521 plus: false,522 params: Some(ps),523 visibility: vis,524 value,525 })526 } else {527 let plus = p.try_eat(T![+]);528 let vis = visibility(p)?;529 let value = Rc::new(expr(p)?);530 Ok(FieldMember {531 name,532 plus,533 params: None,534 visibility: vis,535 value,536 })537 }538}539540fn member(p: &mut Parser<'_>) -> Result<Member> {541 if p.at(T![local]) {542 p.eat(T![local])?;543 Ok(Member::BindStmt(bind(p)?))544 } else if p.at(T![assert]) {545 Ok(Member::AssertStmt(assert_stmt(p)?))546 } else {547 Ok(Member::Field(field(p)?))548 }549}550551fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {552 p.eat(T![for])?;553 let d = destruct(p)?;554 p.eat(T![in])?;555 let over = expr(p)?;556 Ok(ForSpecData { destruct: d, over })557}558559fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {560 let mut specs = Vec::new();561 specs.push(CompSpec::ForSpec(for_spec(p)?));562 loop {563 if p.at(T![for]) {564 specs.push(CompSpec::ForSpec(for_spec(p)?));565 } else if p.at(T![if]) {566 let isd = if_spec_data(p)?;567 specs.push(CompSpec::IfSpec(isd));568 } else {569 break;570 }571 }572 Ok(specs)573}574575fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {576 if p.at(T!['}']) {577 return Ok(ObjBody::MemberList(ObjMembers {578 locals: Rc::new(Vec::new()),579 asserts: Rc::new(Vec::new()),580 fields: Vec::new(),581 }));582 }583584 let mut members = Vec::new();585 loop {586 members.push(member(p)?);587 if !p.try_eat(T![,]) {588 break;589 }590 if p.at(T!['}']) || p.at(T![for]) {591 break;592 }593 }594595 if p.at(T![for]) {596 let specs = compspecs(p)?;597 let mut locals = Vec::new();598 let mut field_member = None;599 for m in members {600 match m {601 Member::Field(f) => {602 if field_member.is_some() {603 return Err(604 p.error("object comprehension can only contain one field".into())605 );606 }607 field_member = Some(f);608 }609 Member::BindStmt(b) => locals.push(b),610 Member::AssertStmt(_) => {611 return Err(p.error("asserts are unsupported in object comprehension".into()));612 }613 }614 }615 Ok(ObjBody::ObjComp(ObjComp {616 locals: Rc::new(locals),617 field: Rc::new(618 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,619 ),620 compspecs: specs,621 }))622 } else {623 let mut locals = Vec::new();624 let mut asserts = Vec::new();625 let mut fields = Vec::new();626 for m in members {627 match m {628 Member::Field(f) => fields.push(f),629 Member::BindStmt(b) => locals.push(b),630 Member::AssertStmt(a) => asserts.push(a),631 }632 }633 Ok(ObjBody::MemberList(ObjMembers {634 locals: Rc::new(locals),635 asserts: Rc::new(asserts),636 fields,637 }))638 }639}640641#[allow(clippy::too_many_lines)]642fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {643 if let Some(lit) = literal(p) {644 return Ok(Expr::Literal(lit));645 }646647 match p.peek() {648 SyntaxKind::STRING_DOUBLE649 | SyntaxKind::STRING_SINGLE650 | SyntaxKind::STRING_DOUBLE_VERBATIM651 | SyntaxKind::STRING_SINGLE_VERBATIM652 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),653654 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),655656 T!['('] => {657 p.eat(T!['('])?;658 let e = expr(p)?;659 p.eat(T![')'])?;660 Ok(e)661 }662663 T!['['] => {664 p.eat(T!['['])?;665 if p.at(T![']']) {666 p.eat(T![']'])?;667 return Ok(Expr::Arr(Rc::new(Vec::new())));668 }669 let first = expr(p)?;670 if p.at(T![for]) {671 let specs = compspecs(p)?;672 p.eat(T![']'])?;673 Ok(Expr::ArrComp(Rc::new(first), specs))674 } else if p.at(T![,]) && {675 let next = p.offset + 1;676 next < p.lexemes.len() && p.lexemes[next].kind == T![for]677 } {678 p.eat(T![,])?;679 let specs = compspecs(p)?;680 p.eat(T![']'])?;681 Ok(Expr::ArrComp(Rc::new(first), specs))682 } else {683 let mut elems = vec![first];684 while p.try_eat(T![,]) {685 if p.at(T![']']) {686 break;687 }688 elems.push(expr(p)?);689 }690 p.eat(T![']'])?;691 Ok(Expr::Arr(Rc::new(elems)))692 }693 }694695 T!['{'] => {696 p.eat(T!['{'])?;697 let body = objinside(p)?;698 p.eat(T!['}'])?;699 Ok(Expr::Obj(body))700 }701702 T![local] => {703 p.eat(T![local])?;704 let mut binds = Vec::new();705 loop {706 binds.push(bind(p)?);707 if !p.try_eat(T![,]) {708 break;709 }710 }711 p.eat(T![;])?;712 let body = expr(p)?;713 Ok(Expr::LocalExpr(binds, Box::new(body)))714 }715716 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),717718 T![function] => {719 p.eat(T![function])?;720 p.eat(T!['('])?;721 let ps = params(p)?;722 p.eat(T![')'])?;723 let body = expr(p)?;724 Ok(Expr::Function(ps, Rc::new(body)))725 }726727 T![assert] => {728 let a = assert_stmt(p)?;729 p.eat(T![;])?;730 let rest = expr(p)?;731 Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))732 }733734 T![error] => {735 let span = spanned(p, |p| p.eat(T![error]))?;736 let e = expr(p)?;737 Ok(Expr::ErrorStmt(span.span, Box::new(e)))738 }739740 T![importstr] => {741 let kind = spanned(p, |p| {742 p.eat(T![importstr])?;743 Ok(ImportKind::Str)744 })?;745 let path = expr(p)?;746 Ok(Expr::Import(kind, Box::new(path)))747 }748749 T![importbin] => {750 let kind = spanned(p, |p| {751 p.eat(T![importbin])?;752 Ok(ImportKind::Bin)753 })?;754 let path = expr(p)?;755 Ok(Expr::Import(kind, Box::new(path)))756 }757758 T![import] => {759 let kind = spanned(p, |p| {760 p.eat(T![import])?;761 Ok(ImportKind::Normal)762 })?;763 let path = expr(p)?;764 Ok(Expr::Import(kind, Box::new(path)))765 }766767 SyntaxKind::IDENT => {768 let n = spanned(p, |p| {769 let s: IStr = p.text().into();770 p.eat_any();771 Ok(s)772 })?;773 Ok(Expr::Var(n))774 }775776 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),777 }778}779780fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {781 if parts.is_empty() {782 return;783 }784 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));785 *e = Expr::Index {786 indexable: Box::new(old),787 parts: std::mem::take(parts),788 };789}790791fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {792 let mut e = expr_basic(p)?;793 794 795 796 let mut parts: Vec<IndexPart> = Vec::new();797798 loop {799 #[cfg(feature = "exp-null-coaelse")]800 if p.at(T![?]) {801 p.eat_any();802 if p.try_eat(T![.]) {803 if p.at(T!['[']) {804 805 p.eat(T!['['])?;806 let idx = spanned(p, expr)?;807 p.eat(T![']'])?;808 parts.push(IndexPart {809 span: idx.span,810 value: idx.value,811 null_coaelse: true,812 });813 } else {814 815 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;816 parts.push(IndexPart {817 span: id_spanned.span,818 value: id_spanned.value,819 null_coaelse: true,820 });821 }822 } else {823 return Err(p.error("expected '.' after '?'".into()));824 }825 continue;826 }827828 if p.at(T![.]) {829 p.eat(T![.])?;830 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;831 parts.push(IndexPart {832 span: id_spanned.span,833 value: id_spanned.value,834 #[cfg(feature = "exp-null-coaelse")]835 null_coaelse: false,836 });837 } else if p.at(T!['[']) {838 p.eat(T!['['])?;839840 if p.at(T![:]) {841 842 flush_index_parts(&mut e, &mut parts);843 let slice = slice_desc(p, None)?;844 p.eat(T![']'])?;845 e = Expr::Slice(Box::new(Slice { value: e, slice }));846 } else {847 let idx = spanned(p, expr)?;848 if p.at(T![:]) {849 850 flush_index_parts(&mut e, &mut parts);851 let slice = slice_desc(p, Some(idx))?;852 p.eat(T![']'])?;853 e = Expr::Slice(Box::new(Slice { value: e, slice }));854 } else {855 856 p.eat(T![']'])?;857 parts.push(IndexPart {858 span: idx.span,859 value: idx.value,860 #[cfg(feature = "exp-null-coaelse")]861 null_coaelse: false,862 });863 }864 }865 } else if p.at(T!['(']) {866 flush_index_parts(&mut e, &mut parts);867 let args_spanned = spanned(p, |p| {868 p.eat(T!['('])?;869 let a = args(p)?;870 p.eat(T![')'])?;871 Ok(a)872 })?;873 let tailstrict = p.try_eat(T![tailstrict]);874 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);875 } else if p.at(T!['{']) {876 flush_index_parts(&mut e, &mut parts);877 p.eat(T!['{'])?;878 let body = objinside(p)?;879 p.eat(T!['}'])?;880 e = Expr::ObjExtend(Rc::new(e), body);881 } else {882 break;883 }884 }885886 flush_index_parts(&mut e, &mut parts);887 Ok(e)888}889890fn prefix_binding_power(op: UnaryOpType) -> u8 {891 match op {892 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,893 }894}895896fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {897 match op {898 BinaryOpType::Or => (2, 3),899 #[cfg(feature = "exp-null-coaelse")]900 BinaryOpType::NullCoaelse => (2, 3),901 BinaryOpType::And => (4, 5),902 BinaryOpType::BitOr => (6, 7),903 BinaryOpType::BitXor => (8, 9),904 BinaryOpType::BitAnd => (10, 11),905 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),906 BinaryOpType::Lt907 | BinaryOpType::Gt908 | BinaryOpType::Lte909 | BinaryOpType::Gte910 | BinaryOpType::In => (14, 15),911 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),912 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),913 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),914 }915}916917fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {918 match kind {919 T![+] => Some(UnaryOpType::Plus),920 T![-] => Some(UnaryOpType::Minus),921 T![!] => Some(UnaryOpType::Not),922 T![~] => Some(UnaryOpType::BitNot),923 _ => None,924 }925}926927fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {928 match p.peek() {929 T![||] => Some(BinaryOpType::Or),930 T![&&] => Some(BinaryOpType::And),931 T![|] => Some(BinaryOpType::BitOr),932 T![^] => Some(BinaryOpType::BitXor),933 T![&] => Some(BinaryOpType::BitAnd),934 T![==] => Some(BinaryOpType::Eq),935 T![!=] => Some(BinaryOpType::Neq),936 T![<] => Some(BinaryOpType::Lt),937 T![>] => Some(BinaryOpType::Gt),938 T![<=] => Some(BinaryOpType::Lte),939 T![>=] => Some(BinaryOpType::Gte),940 T![<<] => Some(BinaryOpType::Lhs),941 T![>>] => Some(BinaryOpType::Rhs),942 T![+] => Some(BinaryOpType::Add),943 T![-] => Some(BinaryOpType::Sub),944 T![*] => Some(BinaryOpType::Mul),945 T![/] => Some(BinaryOpType::Div),946 T![%] => Some(BinaryOpType::Mod),947 T![in] => Some(BinaryOpType::In),948 #[cfg(feature = "exp-null-coaelse")]949 T![??] => Some(BinaryOpType::NullCoaelse),950 _ => None,951 }952}953954fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {955 let mut lhs = if let Some(op) = unary_op(p.peek()) {956 p.eat_any();957 let rbp = prefix_binding_power(op);958 let rhs = expr_bp(p, rbp)?;959 Expr::UnaryOp(op, Box::new(rhs))960 } else {961 expr_suffix(p)?962 };963964 loop {965 if p.at_eof() {966 break;967 }968969 let Some(op) = binary_op(p) else {970 break;971 };972973 let (lbp, rbp) = infix_binding_power(op);974 if lbp < min_bp {975 break;976 }977978 p.eat_any();979 let rhs = expr_bp(p, rbp)?;980 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));981 }982983 Ok(lhs)984}985986fn expr(p: &mut Parser<'_>) -> Result<Expr> {987 expr_bp(p, 0)988}989990pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {991 let mut p = Parser::new(str, settings.source.clone());992 for lexeme in &p.lexemes {993 if let Some(desc) = lexeme.kind.error_description() {994 return Err(ParseError {995 message: desc.to_owned(),996 location: lexeme.range,997 });998 }999 }1000 let e = expr(&mut p)?;1001 if !p.at_eof() {1002 return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1003 }1004 Ok(e)1005}10061007pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1008 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10091010 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1011}10121013#[cfg(test)]1014mod tests {1015 use std::fs;10161017 use insta::{assert_snapshot, glob};1018 use jrsonnet_ir::{IStr, Source};10191020 use super::*;10211022 fn parse_str(input: &str) -> Expr {1023 let source = Source::new_virtual("<test>".into(), input.into());1024 let settings = ParserSettings { source };1025 parse(input, &settings).unwrap()1026 }10271028 #[test]1029 #[cfg(not(feature = "exp-null-coaelse"))]1030 fn basic_test() {1031 let v = parse_str("assert true[false] : false ; true");1032 assert_snapshot!(format!("{v:#?}"));1033 }10341035 #[test]1036 fn literals() {1037 let v = parse_str("[null, true, false, self, super, $]");1038 assert_snapshot!(format!("{v:#?}"));1039 }10401041 #[test]1042 fn basic_math() {1043 let v = parse_str("2+2*2");1044 assert_snapshot!(format!("{v:#?}"));1045 }10461047 #[test]1048 fn underscore_numbers() {1049 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1050 assert_snapshot!(format!("{v:#?}"));1051 }10521053 #[test]1054 fn strings() {1055 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1056 assert_snapshot!(format!("{v:#?}"));1057 }10581059 #[test]1060 fn object() {1061 let v = parse_str("{a: 1, b:: 2, c::: 3}");1062 assert_snapshot!(format!("{v:#?}"));1063 }10641065 #[test]1066 fn function_and_call() {1067 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1068 assert_snapshot!(format!("{v:#?}"));1069 }10701071 #[test]1072 fn if_then_else() {1073 let v = parse_str("if true then 1 else 2");1074 assert_snapshot!(format!("{v:#?}"));1075 }10761077 #[test]1078 fn imports() {1079 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1080 assert_snapshot!(format!("{v:#?}"));1081 }10821083 #[test]1084 fn array_comp() {1085 let v = parse_str("[x for x in arr]");1086 assert_snapshot!(format!("{v:#?}"));1087 }10881089 #[test]1090 #[cfg(not(feature = "exp-null-coaelse"))]1091 fn index_and_suffix() {1092 let v = parse_str("std.test(2).field[0]");1093 assert_snapshot!(format!("{v:#?}"));1094 }10951096 #[test]1097 fn obj_extend() {1098 let v = parse_str("{} { x: 1 }");1099 assert_snapshot!(format!("{v:#?}"));1100 }11011102 #[test]1103 fn unary_ops() {1104 let v = parse_str("!a && !b");1105 assert_snapshot!(format!("{v:#?}"));1106 }11071108 #[test]1109 fn error_expr() {1110 let v = parse_str("error \"bad\"");1111 assert_snapshot!(format!("{v:#?}"));1112 }11131114 #[test]1115 fn slice() {1116 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1117 assert_snapshot!(format!("{v:#?}"));1118 }11191120 #[test]1121 #[cfg(not(feature = "exp-null-coaelse"))]1122 fn peg_snapshots() {1123 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1124 let input = fs::read_to_string(path).expect("read test file");1125 let source = Source::new_virtual("<test>".into(), IStr::empty());1126 let settings = ParserSettings { source };1127 let v = parse(&input, &settings).unwrap();1128 let v = format!("{v:#?}");1129 assert_snapshot!(v);1130 });1131 }1132}