1use jrsonnet_gcmodule::Acyclic;2use jrsonnet_ir::{3 ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,4 ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IdentityKind, IfElse,5 IfSpecData, ImportKind, IndexPart, Member, NumValue, ObjBody, ObjComp, ObjMembers, Slice,6 SliceDesc, Source, Span, Spanned, TrivialVal, UnaryOpType, Visibility, unescape,7};8use jrsonnet_lexer::{Lexeme, Lexer, Span as LexSpan, SyntaxKind, T, collect_lexed_str_block};910pub struct ParserSettings {11 pub source: Source,12}1314#[derive(Debug, Clone)]15pub struct ParseError {16 pub message: String,17 pub location: Span,18}1920impl std::fmt::Display for ParseError {21 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {22 write!(f, "{}", self.message)23 }24}2526type Result<T> = std::result::Result<T, ParseError>;2728struct Parser<'a> {29 lexemes: Vec<Lexeme<'a>>,30 offset: usize,31 source: Source,32}3334impl<'a> Parser<'a> {35 fn new(code: &'a str, source: Source) -> Self {36 Self {37 lexemes: Lexer::new(code)38 .filter(|l| {39 !matches!(40 l.kind,41 SyntaxKind::WHITESPACE42 | SyntaxKind::SINGLE_LINE_SLASH_COMMENT43 | SyntaxKind::SINGLE_LINE_HASH_COMMENT44 | SyntaxKind::MULTI_LINE_COMMENT45 )46 })47 .collect(),48 offset: 0,49 source,50 }51 }5253 fn peek(&self) -> SyntaxKind {54 if self.at_eof() {55 SyntaxKind::EOF56 } else {57 self.lexemes[self.offset].kind58 }59 }6061 fn text(&self) -> &'a str {62 self.lexemes[self.offset].text63 }6465 fn at(&self, kind: SyntaxKind) -> bool {66 !self.at_eof() && self.peek() == kind67 }6869 #[allow(dead_code)]70 fn nth(&self, n: usize) -> SyntaxKind {71 self.lexemes72 .get(self.offset + n)73 .map_or(SyntaxKind::EOF, |l| l.kind)74 }7576 fn eat_any(&mut self) {77 self.offset += 1;78 }7980 fn eat_any_spanned(&mut self) -> Span {81 let start = self.span_start();82 self.eat_any();83 let end = self.span_end();84 Span(self.source.clone(), start, end)85 }8687 fn at_eof(&self) -> bool {88 self.offset >= self.lexemes.len()89 }9091 fn try_eat(&mut self, t: SyntaxKind) -> bool {92 if self.at(t) {93 self.eat_any();94 return true;95 }96 false97 }9899 fn current_desc(&self) -> String {100 if self.at_eof() {101 return "end of file".to_owned();102 }103 let kind = self.peek();104 let text = self.text();105 let name = kind.display_name();106 if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {107 format!("{name} \"{text}\"")108 } else {109 name.to_owned()110 }111 }112113 fn eat(&mut self, t: SyntaxKind) -> Result<()> {114 if !self.at(t) {115 return Err(self.error(format!(116 "expected {}, got {}",117 t.display_name(),118 self.current_desc(),119 )));120 }121 self.eat_any();122 Ok(())123 }124 fn eat_spanned(&mut self, t: SyntaxKind) -> Result<Span> {125 let start = self.span_start();126 self.eat(t)?;127 let end = self.span_end();128 Ok(Span(self.source.clone(), start, end))129 }130131 fn span_start(&self) -> u32 {132 if self.at_eof() {133 if let Some(last) = self.lexemes.last() {134 return last.range.1;135 }136 return 0;137 }138 self.lexemes[self.offset].range.0139 }140141 fn span_end(&self) -> u32 {142 self.lexemes[self.offset - 1].range.1143 }144145 fn error(&self, message: String) -> ParseError {146 if self.offset == self.lexemes.len() {147 let pos = self.lexemes.last().map_or(0, |v| v.range.1);148 return ParseError {149 location: Span(self.source.clone(), pos, pos),150 message,151 };152 }153 let LexSpan(start, end) = self.lexemes[self.offset].range;154 ParseError {155 location: Span(self.source.clone(), start, end),156 message,157 }158 }159}160161fn spanned<T: Acyclic>(162 p: &mut Parser<'_>,163 cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,164) -> Result<Spanned<T>> {165 let start = p.span_start();166 let v = cb(p)?;167 let end = p.span_end();168 Ok(Spanned::new(v, Span(p.source.clone(), start, end)))169}170171fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {172 let kind = p.peek();173 let text = p.text();174 let s = match kind {175 SyntaxKind::STRING_DOUBLE => {176 let inner = &text[1..text.len() - 1];177 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?178 }179 SyntaxKind::STRING_SINGLE => {180 let inner = &text[1..text.len() - 1];181 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?182 }183 SyntaxKind::STRING_DOUBLE_VERBATIM => {184 let inner = &text[2..text.len() - 1];185 inner.replace("\"\"", "\"")186 }187 SyntaxKind::STRING_SINGLE_VERBATIM => {188 let inner = &text[2..text.len() - 1];189 inner.replace("''", "'")190 }191 SyntaxKind::STRING_BLOCK => {192 let inner = &text[3..];193 let collected = collect_lexed_str_block(inner)194 .map_err(|_| p.error("invalid string block".into()))?;195 let mut result = String::new();196 for (i, line) in collected.lines.iter().enumerate() {197 if i > 0 {198 result.push('\n');199 }200 result.push_str(line);201 }202 if !collected.truncate {203 result.push('\n');204 }205 result206 }207 _ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),208 };209 p.eat_any();210 Ok(s.into())211}212213fn is_string_token(kind: SyntaxKind) -> bool {214 matches!(215 kind,216 SyntaxKind::STRING_DOUBLE217 | SyntaxKind::STRING_SINGLE218 | SyntaxKind::STRING_DOUBLE_VERBATIM219 | SyntaxKind::STRING_SINGLE_VERBATIM220 | SyntaxKind::STRING_BLOCK221 )222}223224fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {225 let text = p.text();226 let n: f64 = text227 .replace('_', "")228 .parse()229 .map_err(|_| p.error(format!("invalid number literal: {text}")))?;230231 let v = match NumValue::try_from(n) {232 Ok(v) => v,233 Err(e) => return Err(p.error(format!("invalid number value: {e}"))),234 };235236 p.eat_any();237238 Ok(v)239}240241fn ident(p: &mut Parser<'_>) -> Result<IStr> {242 if !p.at(SyntaxKind::IDENT) {243 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));244 }245 let text = p.text();246 p.eat_any();247 Ok(IStr::from(text))248}249250fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {251 p.eat(T![assert])?;252 let assertion = spanned(p, expr)?;253 let message = if p.try_eat(T![:]) {254 Some(expr(p)?)255 } else {256 None257 };258 Ok(AssertStmt { assertion, message })259}260261fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {262 let v = spanned(p, |p| p.eat(T![if]))?;263 let cond = expr(p)?;264 Ok(IfSpecData { span: v.span, cond })265}266267fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {268 let cond = if_spec_data(p)?;269 p.eat(T![then])?;270 let cond_then = expr(p)?;271 let cond_else = if p.try_eat(T![else]) {272 Some(expr(p)?)273 } else {274 None275 };276 Ok(IfElse {277 cond,278 cond_then,279 cond_else,280 })281}282283fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {284 p.eat(T![:])?;285 let end = if !p.at(T![:]) && !p.at(T![']']) {286 Some(spanned(p, expr)?)287 } else {288 None289 };290 let step = if p.try_eat(T![:]) {291 if p.at(T![']']) {292 None293 } else {294 Some(spanned(p, expr)?)295 }296 } else {297 None298 };299 Ok(SliceDesc { start, end, step })300}301302fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {303 if p.at(SyntaxKind::IDENT) {304 return Ok(Destruct::Full(spanned(p, ident)?));305 }306 #[cfg(not(feature = "exp-destruct"))]307 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));308 #[cfg(feature = "exp-destruct")]309 {310 if p.try_eat(T![?]) {311 return Ok(Destruct::Skip);312 }313 if p.at(T!['[']) {314 return destruct_array(p);315 }316 if p.at(T!['{']) {317 return destruct_object(p);318 }319 Err(p.error(format!(320 "expected destructure pattern, got {}",321 p.current_desc()322 )))323 }324}325326#[cfg(feature = "exp-destruct")]327fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {328 p.eat(T![...])?;329 if p.at(SyntaxKind::IDENT) {330 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))331 } else {332 Ok(jrsonnet_ir::DestructRest::Drop)333 }334}335336#[cfg(feature = "exp-destruct")]337fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {338 p.eat(T!['['])?;339 let mut start = Vec::new();340 let mut rest = None;341 let mut end = Vec::new();342 if !p.at(T![']']) {343 loop {344 if p.at(T![...]) {345 rest = Some(destruct_rest(p)?);346 if p.try_eat(T![,]) {347 if !p.at(T![']']) {348 loop {349 end.push(destruct(p)?);350 if !p.try_eat(T![,]) {351 break;352 }353 if p.at(T![']']) {354 break;355 }356 }357 }358 }359 break;360 }361 start.push(destruct(p)?);362 if !p.try_eat(T![,]) {363 break;364 }365 if p.at(T![']']) {366 break;367 }368 }369 }370 p.eat(T![']'])?;371 Ok(Destruct::Array { start, rest, end })372}373374#[cfg(feature = "exp-destruct")]375fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {376 p.eat(T!['{'])?;377 let mut fields = Vec::new();378 let mut rest = None;379 if !p.at(T!['}']) {380 loop {381 if p.at(T![...]) {382 rest = Some(destruct_rest(p)?);383 p.try_eat(T![,]);384 break;385 }386 let name = ident(p)?;387 let into = if p.try_eat(T![:]) {388 Some(destruct(p)?)389 } else {390 None391 };392 let default = if p.try_eat(T![=]) {393 Some(spanned(p, expr)?)394 } else {395 None396 };397 fields.push((name, into, default));398 if !p.try_eat(T![,]) {399 break;400 }401 if p.at(T!['}']) {402 break;403 }404 }405 }406 p.eat(T!['}'])?;407 Ok(Destruct::Object { fields, rest })408}409410fn params(p: &mut Parser<'_>) -> Result<ExprParams> {411 if p.at(T![')']) {412 return Ok(ExprParams::new(Vec::new()));413 }414 let mut result = Vec::new();415 loop {416 let d = destruct(p)?;417 let default = if p.try_eat(T![=]) {418 Some(expr(p)?)419 } else {420 None421 };422 result.push(ExprParam {423 destruct: d,424 default,425 });426 if !p.try_eat(T![,]) {427 break;428 }429 if p.at(T![')']) {430 break;431 }432 }433 Ok(ExprParams::new(result))434}435436fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {437 if p.at(T![')']) {438 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));439 }440 let mut unnamed = Vec::new();441 let mut names = Vec::new();442 let mut values = Vec::new();443 let mut named_started = false;444 loop {445 let is_named = p.at(SyntaxKind::IDENT) && {446 let next_offset = p.offset + 1;447 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]448 };449 if is_named {450 let name: IStr = ident(p)?;451 p.eat(T![=])?;452453 names.push(name);454 values.push(expr(p)?);455 named_started = true;456 } else {457 if named_started {458 return Err(p.error("positional argument after named argument".into()));459 }460 unnamed.push(expr(p)?);461 }462 if !p.try_eat(T![,]) {463 break;464 }465 if p.at(T![')']) {466 break;467 }468 }469 Ok(ArgsDesc::new(unnamed, names, values))470}471472fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {473 #[cfg(feature = "exp-destruct")]474 {475 if !p.at(SyntaxKind::IDENT) {476 let d = destruct(p)?;477 p.eat(T![=])?;478 return Ok(BindSpec::Field {479 into: d,480 value: expr(p)?,481 });482 }483 }484 let name = spanned(p, ident)?;485 if p.try_eat(T!['(']) {486 let ps = params(p)?;487 p.eat(T![')'])?;488 p.eat(T![=])?;489 Ok(BindSpec::Function {490 name,491 params: ps,492 value: expr(p)?,493 })494 } else {495 p.eat(T![=])?;496 Ok(BindSpec::Field {497 into: Destruct::Full(name),498 value: expr(p)?,499 })500 }501}502503fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {504 p.eat(T![:])?;505 if p.try_eat(T![:]) {506 if p.try_eat(T![:]) {507 Ok(Visibility::Unhide)508 } else {509 Ok(Visibility::Hidden)510 }511 } else {512 Ok(Visibility::Normal)513 }514}515516fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {517 if p.at(SyntaxKind::IDENT) {518 Ok(FieldName::Fixed(ident(p)?))519 } else if is_string_token(p.peek()) {520 Ok(FieldName::Fixed(parse_string_content(p)?))521 } else if p.at(T!['[']) {522 p.eat(T!['['])?;523 let e = expr(p)?;524 p.eat(T![']'])?;525 Ok(FieldName::Dyn(e))526 } else {527 Err(p.error(format!("expected field name, got {}", p.current_desc())))528 }529}530531fn field(p: &mut Parser<'_>) -> Result<FieldMember> {532 let name = spanned(p, field_name)?;533534 if p.at(T!['(']) {535 p.eat(T!['('])?;536 let ps = params(p)?;537 p.eat(T![')'])?;538 let vis = visibility(p)?;539 Ok(FieldMember {540 name,541 plus: false,542 params: Some(ps),543 visibility: vis,544 value: expr(p)?,545 })546 } else {547 let plus = p.try_eat(T![+]);548 let vis = visibility(p)?;549 Ok(FieldMember {550 name,551 plus,552 params: None,553 visibility: vis,554 value: expr(p)?,555 })556 }557}558559fn member(p: &mut Parser<'_>) -> Result<Member> {560 if p.at(T![local]) {561 p.eat(T![local])?;562 Ok(Member::BindStmt(bind(p)?))563 } else if p.at(T![assert]) {564 Ok(Member::AssertStmt(assert_stmt(p)?))565 } else {566 Ok(Member::Field(field(p)?))567 }568}569570fn for_spec(p: &mut Parser<'_>) -> Result<CompSpec> {571 p.eat(T![for])?;572 #[cfg(feature = "exp-object-iteration")]573 if p.at(T!['[']) && p.nth(1) == SyntaxKind::IDENT && p.nth(2) == T![']'] && p.nth(3) == T![:] {574 p.eat(T!['['])?;575 let key = ident(p)?;576 p.eat(T![']'])?;577 let visibility = visibility(p)?;578 let value = destruct(p)?;579 p.eat(T![in])?;580 let over = expr(p)?;581 return Ok(CompSpec::ForObjSpec(jrsonnet_ir::ForObjSpecData {582 key,583 visibility,584 value,585 over,586 }));587 }588 let d = destruct(p)?;589 p.eat(T![in])?;590 let over = expr(p)?;591 Ok(CompSpec::ForSpec(ForSpecData { destruct: d, over }))592}593594fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {595 let mut specs = Vec::new();596 specs.push(for_spec(p)?);597 loop {598 if p.at(T![for]) {599 specs.push(for_spec(p)?);600 } else if p.at(T![if]) {601 let isd = if_spec_data(p)?;602 specs.push(CompSpec::IfSpec(isd));603 } else {604 break;605 }606 }607 Ok(specs)608}609610fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {611 if p.at(T!['}']) {612 return Ok(ObjBody::MemberList(ObjMembers {613 locals: Vec::new(),614 asserts: Vec::new(),615 fields: Vec::new(),616 }));617 }618619 let mut members = Vec::new();620 loop {621 members.push(member(p)?);622 if !p.try_eat(T![,]) {623 break;624 }625 if p.at(T!['}']) || p.at(T![for]) {626 break;627 }628 }629630 if p.at(T![for]) {631 let specs = compspecs(p)?;632 let mut locals = Vec::new();633 let mut field_member = None;634 for m in members {635 match m {636 Member::Field(f) => {637 if field_member.is_some() {638 return Err(639 p.error("object comprehension can only contain one field".into())640 );641 }642 field_member = Some(f);643 }644 Member::BindStmt(b) => locals.push(b),645 Member::AssertStmt(_) => {646 return Err(p.error("asserts are unsupported in object comprehension".into()));647 }648 }649 }650 Ok(ObjBody::ObjComp(ObjComp {651 locals,652 field: Box::new(653 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,654 ),655 compspecs: specs,656 }))657 } else {658 let mut locals = Vec::new();659 let mut asserts = Vec::new();660 let mut fields = Vec::new();661 for m in members {662 match m {663 Member::Field(f) => fields.push(f),664 Member::BindStmt(b) => locals.push(b),665 Member::AssertStmt(a) => asserts.push(a),666 }667 }668 Ok(ObjBody::MemberList(ObjMembers {669 locals,670 asserts,671 fields,672 }))673 }674}675676#[allow(clippy::too_many_lines)]677fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {678 match p.peek() {679 T![self] => Ok(Expr::Identity(p.eat_any_spanned(), IdentityKind::This)),680 T![super] => Ok(Expr::Identity(p.eat_any_spanned(), IdentityKind::Super)),681 T!['$'] => Ok(Expr::Identity(p.eat_any_spanned(), IdentityKind::Dollar)),682 T![null] => {683 p.eat_any();684 Ok(Expr::Trivial(TrivialVal::Null))685 }686 T![true] => {687 p.eat_any();688 Ok(Expr::Trivial(TrivialVal::Bool(true)))689 }690 T![false] => {691 p.eat_any();692 Ok(Expr::Trivial(TrivialVal::Bool(false)))693 }694695 SyntaxKind::STRING_DOUBLE696 | SyntaxKind::STRING_SINGLE697 | SyntaxKind::STRING_DOUBLE_VERBATIM698 | SyntaxKind::STRING_SINGLE_VERBATIM699 | SyntaxKind::STRING_BLOCK => Ok(Expr::Trivial(TrivialVal::Str(parse_string_content(p)?))),700701 SyntaxKind::FLOAT => Ok(Expr::Trivial(TrivialVal::Num(parse_number(p)?))),702703 T!['('] => {704 p.eat(T!['('])?;705 let e = expr(p)?;706 p.eat(T![')'])?;707 Ok(e)708 }709710 T!['['] => {711 p.eat(T!['['])?;712 if p.at(T![']']) {713 p.eat(T![']'])?;714 return Ok(Expr::Arr(Vec::new()));715 }716 let first = expr(p)?;717 if p.at(T![for]) {718 let specs = compspecs(p)?;719 p.eat(T![']'])?;720 Ok(Expr::ArrComp(Box::new(first), specs))721 } else if p.at(T![,]) && {722 let next = p.offset + 1;723 next < p.lexemes.len() && p.lexemes[next].kind == T![for]724 } {725 p.eat(T![,])?;726 let specs = compspecs(p)?;727 p.eat(T![']'])?;728 Ok(Expr::ArrComp(Box::new(first), specs))729 } else {730 let mut elems = vec![first];731 while p.try_eat(T![,]) {732 if p.at(T![']']) {733 break;734 }735 elems.push(expr(p)?);736 }737 p.eat(T![']'])?;738 Ok(Expr::Arr(elems))739 }740 }741742 T!['{'] => {743 p.eat(T!['{'])?;744 let body = objinside(p)?;745 p.eat(T!['}'])?;746 Ok(Expr::Obj(body))747 }748749 T![local] => {750 p.eat(T![local])?;751 let mut binds = Vec::new();752 loop {753 if p.at(T![;]) {754 break;755 }756 binds.push(bind(p)?);757 if !p.try_eat(T![,]) {758 break;759 }760 }761 p.eat(T![;])?;762 let body = expr(p)?;763 Ok(Expr::LocalExpr(binds, Box::new(body)))764 }765766 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),767768 T![function] => {769 let span = p.eat_spanned(T![function])?;770 p.eat(T!['('])?;771 let ps = params(p)?;772 p.eat(T![')'])?;773 let body = expr(p)?;774 Ok(Expr::Function(span, ps, Box::new(body)))775 }776777 T![assert] => {778 let a = assert_stmt(p)?;779 p.eat(T![;])?;780 let rest = expr(p)?;781 Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))782 }783784 T![error] => {785 let span = spanned(p, |p| p.eat(T![error]))?;786 let e = expr(p)?;787 Ok(Expr::ErrorStmt(span.span, Box::new(e)))788 }789790 T![importstr] => {791 let kind = spanned(p, |p| {792 p.eat(T![importstr])?;793 Ok(ImportKind::Str)794 })?;795 let path = expr(p)?;796 Ok(Expr::Import(kind, Box::new(path)))797 }798799 T![importbin] => {800 let kind = spanned(p, |p| {801 p.eat(T![importbin])?;802 Ok(ImportKind::Bin)803 })?;804 let path = expr(p)?;805 Ok(Expr::Import(kind, Box::new(path)))806 }807808 T![import] => {809 let kind = spanned(p, |p| {810 p.eat(T![import])?;811 Ok(ImportKind::Normal)812 })?;813 let path = expr(p)?;814 Ok(Expr::Import(kind, Box::new(path)))815 }816817 SyntaxKind::IDENT => {818 let n = spanned(p, |p| {819 let s: IStr = p.text().into();820 p.eat_any();821 Ok(s)822 })?;823 Ok(Expr::Var(n))824 }825826 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),827 }828}829830fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {831 if parts.is_empty() {832 return;833 }834 let old = std::mem::replace(e, Expr::Trivial(TrivialVal::Null));835 *e = Expr::Index {836 indexable: Box::new(old),837 parts: std::mem::take(parts),838 };839}840841fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {842 let mut e = expr_basic(p)?;843 844 845 846 let mut parts: Vec<IndexPart> = Vec::new();847848 loop {849 #[cfg(feature = "exp-null-coaelse")]850 if p.at(T![?]) {851 p.eat_any();852 if p.try_eat(T![.]) {853 if p.at(T!['[']) {854 855 p.eat(T!['['])?;856 let idx = spanned(p, expr)?;857 p.eat(T![']'])?;858 parts.push(IndexPart {859 span: idx.span,860 value: idx.value,861 null_coaelse: true,862 });863 } else {864 865 let id_spanned = spanned(p, |p| Ok(Expr::Trivial(TrivialVal::Str(ident(p)?))))?;866 parts.push(IndexPart {867 span: id_spanned.span,868 value: id_spanned.value,869 null_coaelse: true,870 });871 }872 } else {873 return Err(p.error("expected '.' after '?'".into()));874 }875 continue;876 }877878 if p.at(T![.]) {879 p.eat(T![.])?;880 let id_spanned = spanned(p, |p| Ok(Expr::Trivial(TrivialVal::Str(ident(p)?))))?;881 parts.push(IndexPart {882 span: id_spanned.span,883 value: id_spanned.value,884 #[cfg(feature = "exp-null-coaelse")]885 null_coaelse: false,886 });887 } else if p.at(T!['[']) {888 p.eat(T!['['])?;889890 if p.at(T![:]) {891 892 flush_index_parts(&mut e, &mut parts);893 let slice = slice_desc(p, None)?;894 p.eat(T![']'])?;895 e = Expr::Slice(Box::new(Slice { value: e, slice }));896 } else {897 let idx = spanned(p, expr)?;898 if p.at(T![:]) {899 900 flush_index_parts(&mut e, &mut parts);901 let slice = slice_desc(p, Some(idx))?;902 p.eat(T![']'])?;903 e = Expr::Slice(Box::new(Slice { value: e, slice }));904 } else {905 906 p.eat(T![']'])?;907 parts.push(IndexPart {908 span: idx.span,909 value: idx.value,910 #[cfg(feature = "exp-null-coaelse")]911 null_coaelse: false,912 });913 }914 }915 } else if p.at(T!['(']) {916 flush_index_parts(&mut e, &mut parts);917 let args_spanned = spanned(p, |p| {918 p.eat(T!['('])?;919 let a = args(p)?;920 p.eat(T![')'])?;921 Ok(a)922 })?;923 let tailstrict = p.try_eat(T![tailstrict]);924 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);925 } else if p.at(T!['{']) {926 flush_index_parts(&mut e, &mut parts);927 p.eat(T!['{'])?;928 let body = objinside(p)?;929 p.eat(T!['}'])?;930 e = Expr::ObjExtend(Box::new(e), body);931 } else {932 break;933 }934 }935936 flush_index_parts(&mut e, &mut parts);937 Ok(e)938}939940fn prefix_binding_power(op: UnaryOpType) -> u8 {941 match op {942 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,943 }944}945946fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {947 match op {948 BinaryOpType::Or => (2, 3),949 #[cfg(feature = "exp-null-coaelse")]950 BinaryOpType::NullCoaelse => (2, 3),951 BinaryOpType::And => (4, 5),952 BinaryOpType::BitOr => (6, 7),953 BinaryOpType::BitXor => (8, 9),954 BinaryOpType::BitAnd => (10, 11),955 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),956 BinaryOpType::Lt957 | BinaryOpType::Gt958 | BinaryOpType::Lte959 | BinaryOpType::Gte960 | BinaryOpType::In => (14, 15),961 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),962 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),963 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),964 }965}966967fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {968 match kind {969 T![+] => Some(UnaryOpType::Plus),970 T![-] => Some(UnaryOpType::Minus),971 T![!] => Some(UnaryOpType::Not),972 T![~] => Some(UnaryOpType::BitNot),973 _ => None,974 }975}976977fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {978 match p.peek() {979 T![||] => Some(BinaryOpType::Or),980 T![&&] => Some(BinaryOpType::And),981 T![|] => Some(BinaryOpType::BitOr),982 T![^] => Some(BinaryOpType::BitXor),983 T![&] => Some(BinaryOpType::BitAnd),984 T![==] => Some(BinaryOpType::Eq),985 T![!=] => Some(BinaryOpType::Neq),986 T![<] => Some(BinaryOpType::Lt),987 T![>] => Some(BinaryOpType::Gt),988 T![<=] => Some(BinaryOpType::Lte),989 T![>=] => Some(BinaryOpType::Gte),990 T![<<] => Some(BinaryOpType::Lhs),991 T![>>] => Some(BinaryOpType::Rhs),992 T![+] => Some(BinaryOpType::Add),993 T![-] => Some(BinaryOpType::Sub),994 T![*] => Some(BinaryOpType::Mul),995 T![/] => Some(BinaryOpType::Div),996 T![%] => Some(BinaryOpType::Mod),997 T![in] => Some(BinaryOpType::In),998 #[cfg(feature = "exp-null-coaelse")]999 T![??] => Some(BinaryOpType::NullCoaelse),1000 _ => None,1001 }1002}10031004fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {1005 let mut lhs = if let Some(op) = unary_op(p.peek()) {1006 p.eat_any();1007 let rbp = prefix_binding_power(op);1008 let rhs = expr_bp(p, rbp)?;1009 Expr::UnaryOp(op, Box::new(rhs))1010 } else {1011 expr_suffix(p)?1012 };10131014 loop {1015 if p.at_eof() {1016 break;1017 }10181019 let Some(op) = binary_op(p) else {1020 break;1021 };10221023 let (lbp, rbp) = infix_binding_power(op);1024 if lbp < min_bp {1025 break;1026 }10271028 p.eat_any();1029 let rhs = expr_bp(p, rbp)?;1030 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1031 }10321033 Ok(lhs)1034}10351036fn expr(p: &mut Parser<'_>) -> Result<Expr> {1037 expr_bp(p, 0)1038}10391040pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1041 let mut p = Parser::new(str, settings.source.clone());1042 for lexeme in &p.lexemes {1043 if let Some(desc) = lexeme.kind.error_description() {1044 return Err(ParseError {1045 message: desc.to_owned(),1046 location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1047 });1048 }1049 }1050 let e = expr(&mut p)?;1051 if !p.at_eof() {1052 return Err(p.error(format!("expected end of file, got {}", p.current_desc())));1053 }1054 Ok(e)1055}10561057pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1058 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10591060 Spanned::new(1061 Expr::Trivial(TrivialVal::Str(s)),1062 Span(settings.source.clone(), 0, len),1063 )1064}10651066#[cfg(test)]1067mod tests {1068 use insta::assert_snapshot;10691070 use super::*;10711072 fn parse_str(input: &str) -> Expr {1073 let source = Source::new_virtual("<test>".into(), input.into());1074 let settings = ParserSettings { source };1075 parse(input, &settings).unwrap()1076 }10771078 #[test]1079 #[cfg(not(feature = "exp-null-coaelse"))]1080 fn basic_test() {1081 let v = parse_str("assert true[false] : false ; true");1082 assert_snapshot!(format!("{v:#?}"));1083 }10841085 #[test]1086 fn literals() {1087 let v = parse_str("[null, true, false, self, super, $]");1088 assert_snapshot!(format!("{v:#?}"));1089 }10901091 #[test]1092 fn basic_math() {1093 let v = parse_str("2+2*2");1094 assert_snapshot!(format!("{v:#?}"));1095 }10961097 #[test]1098 fn underscore_numbers() {1099 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1100 assert_snapshot!(format!("{v:#?}"));1101 }11021103 #[test]1104 fn strings() {1105 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1106 assert_snapshot!(format!("{v:#?}"));1107 }11081109 #[test]1110 fn object() {1111 let v = parse_str("{a: 1, b:: 2, c::: 3}");1112 assert_snapshot!(format!("{v:#?}"));1113 }11141115 #[test]1116 fn function_and_call() {1117 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1118 assert_snapshot!(format!("{v:#?}"));1119 }11201121 #[test]1122 fn if_then_else() {1123 let v = parse_str("if true then 1 else 2");1124 assert_snapshot!(format!("{v:#?}"));1125 }11261127 #[test]1128 fn imports() {1129 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1130 assert_snapshot!(format!("{v:#?}"));1131 }11321133 #[test]1134 fn array_comp() {1135 let v = parse_str("[x for x in arr]");1136 assert_snapshot!(format!("{v:#?}"));1137 }11381139 #[test]1140 #[cfg(not(feature = "exp-null-coaelse"))]1141 fn index_and_suffix() {1142 let v = parse_str("std.test(2).field[0]");1143 assert_snapshot!(format!("{v:#?}"));1144 }11451146 #[test]1147 fn obj_extend() {1148 let v = parse_str("{} { x: 1 }");1149 assert_snapshot!(format!("{v:#?}"));1150 }11511152 #[test]1153 fn unary_ops() {1154 let v = parse_str("!a && !b");1155 assert_snapshot!(format!("{v:#?}"));1156 }11571158 #[test]1159 fn error_expr() {1160 let v = parse_str("error \"bad\"");1161 assert_snapshot!(format!("{v:#?}"));1162 }11631164 #[test]1165 fn slice() {1166 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1167 assert_snapshot!(format!("{v:#?}"));1168 }11691170 #[test]1171 #[cfg(not(feature = "exp-null-coaelse"))]1172 fn peg_snapshots() {1173 use std::fs;11741175 use insta::glob;1176 use jrsonnet_ir::{IStr, Source};11771178 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1179 let input = fs::read_to_string(path).expect("read test file");1180 let source = Source::new_virtual("<test>".into(), IStr::empty());1181 let settings = ParserSettings { source };1182 let v = parse(&input, &settings).unwrap();1183 let v = format!("{v:#?}");1184 assert_snapshot!(v);1185 });1186 }1187}