1use jrsonnet_gcmodule::Acyclic;2use jrsonnet_ir::{3 ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,4 ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,5 ImportKind, IndexPart, LiteralType, Member, NumValue, ObjBody, ObjComp, ObjMembers, Slice,6 SliceDesc, Source, Span, Spanned, 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 at_eof(&self) -> bool {81 self.offset >= self.lexemes.len()82 }8384 fn try_eat(&mut self, t: SyntaxKind) -> bool {85 if self.at(t) {86 self.eat_any();87 return true;88 }89 false90 }9192 fn current_desc(&self) -> String {93 if self.at_eof() {94 return "end of file".to_owned();95 }96 let kind = self.peek();97 let text = self.text();98 let name = kind.display_name();99 if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {100 format!("{name} \"{text}\"")101 } else {102 name.to_owned()103 }104 }105106 fn eat(&mut self, t: SyntaxKind) -> Result<()> {107 if !self.at(t) {108 return Err(self.error(format!(109 "expected {}, got {}",110 t.display_name(),111 self.current_desc(),112 )));113 }114 self.eat_any();115 Ok(())116 }117118 fn span_start(&self) -> u32 {119 if self.at_eof() {120 if let Some(last) = self.lexemes.last() {121 return last.range.1;122 }123 return 0;124 }125 self.lexemes[self.offset].range.0126 }127128 fn span_end(&self) -> u32 {129 self.lexemes[self.offset - 1].range.1130 }131132 fn error(&self, message: String) -> ParseError {133 if self.offset == self.lexemes.len() {134 let pos = self.lexemes.last().map_or(0, |v| v.range.1);135 return ParseError {136 location: Span(self.source.clone(), pos, pos),137 message,138 };139 }140 let LexSpan(start, end) = self.lexemes[self.offset].range;141 ParseError {142 location: Span(self.source.clone(), start, end),143 message,144 }145 }146}147148fn spanned<T: Acyclic>(149 p: &mut Parser<'_>,150 cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,151) -> Result<Spanned<T>> {152 let start = p.span_start();153 let v = cb(p)?;154 let end = p.span_end();155 Ok(Spanned::new(v, Span(p.source.clone(), start, end)))156}157158fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {159 let kind = p.peek();160 let text = p.text();161 let s = match kind {162 SyntaxKind::STRING_DOUBLE => {163 let inner = &text[1..text.len() - 1];164 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?165 }166 SyntaxKind::STRING_SINGLE => {167 let inner = &text[1..text.len() - 1];168 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?169 }170 SyntaxKind::STRING_DOUBLE_VERBATIM => {171 let inner = &text[2..text.len() - 1];172 inner.replace("\"\"", "\"")173 }174 SyntaxKind::STRING_SINGLE_VERBATIM => {175 let inner = &text[2..text.len() - 1];176 inner.replace("''", "'")177 }178 SyntaxKind::STRING_BLOCK => {179 let inner = &text[3..];180 let collected = collect_lexed_str_block(inner)181 .map_err(|_| p.error("invalid string block".into()))?;182 let mut result = String::new();183 for (i, line) in collected.lines.iter().enumerate() {184 if i > 0 {185 result.push('\n');186 }187 result.push_str(line);188 }189 if !collected.truncate {190 result.push('\n');191 }192 result193 }194 _ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),195 };196 p.eat_any();197 Ok(s.into())198}199200fn is_string_token(kind: SyntaxKind) -> bool {201 matches!(202 kind,203 SyntaxKind::STRING_DOUBLE204 | SyntaxKind::STRING_SINGLE205 | SyntaxKind::STRING_DOUBLE_VERBATIM206 | SyntaxKind::STRING_SINGLE_VERBATIM207 | SyntaxKind::STRING_BLOCK208 )209}210211fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {212 let text = p.text();213 let n: f64 = text214 .replace('_', "")215 .parse()216 .map_err(|_| p.error(format!("invalid number literal: {text}")))?;217218 let v = match NumValue::try_from(n) {219 Ok(v) => v,220 Err(e) => return Err(p.error(format!("invalid number value: {e}"))),221 };222223 p.eat_any();224225 Ok(v)226}227228fn ident(p: &mut Parser<'_>) -> Result<IStr> {229 if !p.at(SyntaxKind::IDENT) {230 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));231 }232 let text = p.text();233 p.eat_any();234 Ok(IStr::from(text))235}236237fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {238 let t = match p.peek() {239 T![self] => LiteralType::This,240 T![super] => LiteralType::Super,241 T!['$'] => LiteralType::Dollar,242 T![null] => LiteralType::Null,243 T![true] => LiteralType::True,244 T![false] => LiteralType::False,245 _ => return None,246 };247 p.eat_any();248 Some(t)249}250251fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {252 p.eat(T![assert])?;253 let assertion = spanned(p, expr)?;254 let message = if p.try_eat(T![:]) {255 Some(expr(p)?)256 } else {257 None258 };259 Ok(AssertStmt { assertion, message })260}261262fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {263 let v = spanned(p, |p| p.eat(T![if]))?;264 let cond = expr(p)?;265 Ok(IfSpecData { span: v.span, cond })266}267268fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {269 let cond = if_spec_data(p)?;270 p.eat(T![then])?;271 let cond_then = expr(p)?;272 let cond_else = if p.try_eat(T![else]) {273 Some(expr(p)?)274 } else {275 None276 };277 Ok(IfElse {278 cond,279 cond_then,280 cond_else,281 })282}283284fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {285 p.eat(T![:])?;286 let end = if !p.at(T![:]) && !p.at(T![']']) {287 Some(spanned(p, expr)?)288 } else {289 None290 };291 let step = if p.try_eat(T![:]) {292 if p.at(T![']']) {293 None294 } else {295 Some(spanned(p, expr)?)296 }297 } else {298 None299 };300 Ok(SliceDesc { start, end, step })301}302303fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {304 if p.at(SyntaxKind::IDENT) {305 return Ok(Destruct::Full(spanned(p, ident)?));306 }307 #[cfg(not(feature = "exp-destruct"))]308 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));309 #[cfg(feature = "exp-destruct")]310 {311 if p.try_eat(T![?]) {312 return Ok(Destruct::Skip);313 }314 if p.at(T!['[']) {315 return destruct_array(p);316 }317 if p.at(T!['{']) {318 return destruct_object(p);319 }320 Err(p.error(format!(321 "expected destructure pattern, got {}",322 p.current_desc()323 )))324 }325}326327#[cfg(feature = "exp-destruct")]328fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {329 p.eat(T![...])?;330 if p.at(SyntaxKind::IDENT) {331 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))332 } else {333 Ok(jrsonnet_ir::DestructRest::Drop)334 }335}336337#[cfg(feature = "exp-destruct")]338fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {339 p.eat(T!['['])?;340 let mut start = Vec::new();341 let mut rest = None;342 let mut end = Vec::new();343 if !p.at(T![']']) {344 loop {345 if p.at(T![...]) {346 rest = Some(destruct_rest(p)?);347 if p.try_eat(T![,]) {348 if !p.at(T![']']) {349 loop {350 end.push(destruct(p)?);351 if !p.try_eat(T![,]) {352 break;353 }354 if p.at(T![']']) {355 break;356 }357 }358 }359 }360 break;361 }362 start.push(destruct(p)?);363 if !p.try_eat(T![,]) {364 break;365 }366 if p.at(T![']']) {367 break;368 }369 }370 }371 p.eat(T![']'])?;372 Ok(Destruct::Array { start, rest, end })373}374375#[cfg(feature = "exp-destruct")]376fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {377 p.eat(T!['{'])?;378 let mut fields = Vec::new();379 let mut rest = None;380 if !p.at(T!['}']) {381 loop {382 if p.at(T![...]) {383 rest = Some(destruct_rest(p)?);384 p.try_eat(T![,]);385 break;386 }387 let name = ident(p)?;388 let into = if p.try_eat(T![:]) {389 Some(destruct(p)?)390 } else {391 None392 };393 let default = if p.try_eat(T![=]) {394 Some(spanned(p, expr)?)395 } else {396 None397 };398 fields.push((name, into, default));399 if !p.try_eat(T![,]) {400 break;401 }402 if p.at(T!['}']) {403 break;404 }405 }406 }407 p.eat(T!['}'])?;408 Ok(Destruct::Object { fields, rest })409}410411fn params(p: &mut Parser<'_>) -> Result<ExprParams> {412 if p.at(T![')']) {413 return Ok(ExprParams::new(Vec::new()));414 }415 let mut result = Vec::new();416 loop {417 let d = destruct(p)?;418 let default = if p.try_eat(T![=]) {419 Some(expr(p)?)420 } else {421 None422 };423 result.push(ExprParam {424 destruct: d,425 default,426 });427 if !p.try_eat(T![,]) {428 break;429 }430 if p.at(T![')']) {431 break;432 }433 }434 Ok(ExprParams::new(result))435}436437fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {438 if p.at(T![')']) {439 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));440 }441 let mut unnamed = Vec::new();442 let mut names = Vec::new();443 let mut values = Vec::new();444 let mut named_started = false;445 loop {446 let is_named = p.at(SyntaxKind::IDENT) && {447 let next_offset = p.offset + 1;448 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]449 };450 if is_named {451 let name: IStr = ident(p)?;452 p.eat(T![=])?;453454 names.push(name);455 values.push(expr(p)?);456 named_started = true;457 } else {458 if named_started {459 return Err(p.error("positional argument after named argument".into()));460 }461 unnamed.push(expr(p)?);462 }463 if !p.try_eat(T![,]) {464 break;465 }466 if p.at(T![')']) {467 break;468 }469 }470 Ok(ArgsDesc::new(unnamed, names, values))471}472473fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {474 #[cfg(feature = "exp-destruct")]475 {476 if !p.at(SyntaxKind::IDENT) {477 let d = destruct(p)?;478 p.eat(T![=])?;479 return Ok(BindSpec::Field {480 into: d,481 value: expr(p)?,482 });483 }484 }485 let name_spanned = spanned(p, ident)?;486 if p.try_eat(T!['(']) {487 let ps = params(p)?;488 p.eat(T![')'])?;489 p.eat(T![=])?;490 Ok(BindSpec::Function {491 name: name_spanned.value,492 params: ps,493 value: expr(p)?,494 })495 } else {496 p.eat(T![=])?;497 Ok(BindSpec::Field {498 into: Destruct::Full(name_spanned),499 value: expr(p)?,500 })501 }502}503504fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {505 p.eat(T![:])?;506 if p.try_eat(T![:]) {507 if p.try_eat(T![:]) {508 Ok(Visibility::Unhide)509 } else {510 Ok(Visibility::Hidden)511 }512 } else {513 Ok(Visibility::Normal)514 }515}516517fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {518 if p.at(SyntaxKind::IDENT) {519 Ok(FieldName::Fixed(ident(p)?))520 } else if is_string_token(p.peek()) {521 Ok(FieldName::Fixed(parse_string_content(p)?))522 } else if p.at(T!['[']) {523 p.eat(T!['['])?;524 let e = expr(p)?;525 p.eat(T![']'])?;526 Ok(FieldName::Dyn(e))527 } else {528 Err(p.error(format!("expected field name, got {}", p.current_desc())))529 }530}531532fn field(p: &mut Parser<'_>) -> Result<FieldMember> {533 let name = spanned(p, field_name)?;534535 if p.at(T!['(']) {536 p.eat(T!['('])?;537 let ps = params(p)?;538 p.eat(T![')'])?;539 let vis = visibility(p)?;540 Ok(FieldMember {541 name,542 plus: false,543 params: Some(ps),544 visibility: vis,545 value: expr(p)?,546 })547 } else {548 let plus = p.try_eat(T![+]);549 let vis = visibility(p)?;550 Ok(FieldMember {551 name,552 plus,553 params: None,554 visibility: vis,555 value: expr(p)?,556 })557 }558}559560fn member(p: &mut Parser<'_>) -> Result<Member> {561 if p.at(T![local]) {562 p.eat(T![local])?;563 Ok(Member::BindStmt(bind(p)?))564 } else if p.at(T![assert]) {565 Ok(Member::AssertStmt(assert_stmt(p)?))566 } else {567 Ok(Member::Field(field(p)?))568 }569}570571fn for_spec(p: &mut Parser<'_>) -> Result<CompSpec> {572 p.eat(T![for])?;573 #[cfg(feature = "exp-object-iteration")]574 if p.at(T!['[']) && p.nth(1) == SyntaxKind::IDENT && p.nth(2) == T![']'] && p.nth(3) == T![:] {575 p.eat(T!['['])?;576 let key = ident(p)?;577 p.eat(T![']'])?;578 let visibility = visibility(p)?;579 let value = destruct(p)?;580 p.eat(T![in])?;581 let over = expr(p)?;582 return Ok(CompSpec::ForObjSpec(jrsonnet_ir::ForObjSpecData {583 key,584 visibility,585 value,586 over,587 }));588 }589 let d = destruct(p)?;590 p.eat(T![in])?;591 let over = expr(p)?;592 Ok(CompSpec::ForSpec(ForSpecData { destruct: d, over }))593}594595fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {596 let mut specs = Vec::new();597 specs.push(for_spec(p)?);598 loop {599 if p.at(T![for]) {600 specs.push(for_spec(p)?);601 } else if p.at(T![if]) {602 let isd = if_spec_data(p)?;603 specs.push(CompSpec::IfSpec(isd));604 } else {605 break;606 }607 }608 Ok(specs)609}610611fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {612 if p.at(T!['}']) {613 return Ok(ObjBody::MemberList(ObjMembers {614 locals: Vec::new(),615 asserts: Vec::new(),616 fields: Vec::new(),617 }));618 }619620 let mut members = Vec::new();621 loop {622 members.push(member(p)?);623 if !p.try_eat(T![,]) {624 break;625 }626 if p.at(T!['}']) || p.at(T![for]) {627 break;628 }629 }630631 if p.at(T![for]) {632 let specs = compspecs(p)?;633 let mut locals = Vec::new();634 let mut field_member = None;635 for m in members {636 match m {637 Member::Field(f) => {638 if field_member.is_some() {639 return Err(640 p.error("object comprehension can only contain one field".into())641 );642 }643 field_member = Some(f);644 }645 Member::BindStmt(b) => locals.push(b),646 Member::AssertStmt(_) => {647 return Err(p.error("asserts are unsupported in object comprehension".into()));648 }649 }650 }651 Ok(ObjBody::ObjComp(ObjComp {652 locals,653 field: Box::new(654 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,655 ),656 compspecs: specs,657 }))658 } else {659 let mut locals = Vec::new();660 let mut asserts = Vec::new();661 let mut fields = Vec::new();662 for m in members {663 match m {664 Member::Field(f) => fields.push(f),665 Member::BindStmt(b) => locals.push(b),666 Member::AssertStmt(a) => asserts.push(a),667 }668 }669 Ok(ObjBody::MemberList(ObjMembers {670 locals,671 asserts,672 fields,673 }))674 }675}676677#[allow(clippy::too_many_lines)]678fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {679 if let Some(lit) = literal(p) {680 return Ok(Expr::Literal(lit));681 }682683 match p.peek() {684 SyntaxKind::STRING_DOUBLE685 | SyntaxKind::STRING_SINGLE686 | SyntaxKind::STRING_DOUBLE_VERBATIM687 | SyntaxKind::STRING_SINGLE_VERBATIM688 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),689690 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),691692 T!['('] => {693 p.eat(T!['('])?;694 let e = expr(p)?;695 p.eat(T![')'])?;696 Ok(e)697 }698699 T!['['] => {700 p.eat(T!['['])?;701 if p.at(T![']']) {702 p.eat(T![']'])?;703 return Ok(Expr::Arr(Vec::new()));704 }705 let first = expr(p)?;706 if p.at(T![for]) {707 let specs = compspecs(p)?;708 p.eat(T![']'])?;709 Ok(Expr::ArrComp(Box::new(first), specs))710 } else if p.at(T![,]) && {711 let next = p.offset + 1;712 next < p.lexemes.len() && p.lexemes[next].kind == T![for]713 } {714 p.eat(T![,])?;715 let specs = compspecs(p)?;716 p.eat(T![']'])?;717 Ok(Expr::ArrComp(Box::new(first), specs))718 } else {719 let mut elems = vec![first];720 while p.try_eat(T![,]) {721 if p.at(T![']']) {722 break;723 }724 elems.push(expr(p)?);725 }726 p.eat(T![']'])?;727 Ok(Expr::Arr(elems))728 }729 }730731 T!['{'] => {732 p.eat(T!['{'])?;733 let body = objinside(p)?;734 p.eat(T!['}'])?;735 Ok(Expr::Obj(body))736 }737738 T![local] => {739 p.eat(T![local])?;740 let mut binds = Vec::new();741 loop {742 if p.at(T![;]) {743 break;744 }745 binds.push(bind(p)?);746 if !p.try_eat(T![,]) {747 break;748 }749 }750 p.eat(T![;])?;751 let body = expr(p)?;752 Ok(Expr::LocalExpr(binds, Box::new(body)))753 }754755 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),756757 T![function] => {758 p.eat(T![function])?;759 p.eat(T!['('])?;760 let ps = params(p)?;761 p.eat(T![')'])?;762 let body = expr(p)?;763 Ok(Expr::Function(ps, Box::new(body)))764 }765766 T![assert] => {767 let a = assert_stmt(p)?;768 p.eat(T![;])?;769 let rest = expr(p)?;770 Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))771 }772773 T![error] => {774 let span = spanned(p, |p| p.eat(T![error]))?;775 let e = expr(p)?;776 Ok(Expr::ErrorStmt(span.span, Box::new(e)))777 }778779 T![importstr] => {780 let kind = spanned(p, |p| {781 p.eat(T![importstr])?;782 Ok(ImportKind::Str)783 })?;784 let path = expr(p)?;785 Ok(Expr::Import(kind, Box::new(path)))786 }787788 T![importbin] => {789 let kind = spanned(p, |p| {790 p.eat(T![importbin])?;791 Ok(ImportKind::Bin)792 })?;793 let path = expr(p)?;794 Ok(Expr::Import(kind, Box::new(path)))795 }796797 T![import] => {798 let kind = spanned(p, |p| {799 p.eat(T![import])?;800 Ok(ImportKind::Normal)801 })?;802 let path = expr(p)?;803 Ok(Expr::Import(kind, Box::new(path)))804 }805806 SyntaxKind::IDENT => {807 let n = spanned(p, |p| {808 let s: IStr = p.text().into();809 p.eat_any();810 Ok(s)811 })?;812 Ok(Expr::Var(n))813 }814815 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),816 }817}818819fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {820 if parts.is_empty() {821 return;822 }823 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));824 *e = Expr::Index {825 indexable: Box::new(old),826 parts: std::mem::take(parts),827 };828}829830fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {831 let mut e = expr_basic(p)?;832 833 834 835 let mut parts: Vec<IndexPart> = Vec::new();836837 loop {838 #[cfg(feature = "exp-null-coaelse")]839 if p.at(T![?]) {840 p.eat_any();841 if p.try_eat(T![.]) {842 if p.at(T!['[']) {843 844 p.eat(T!['['])?;845 let idx = spanned(p, expr)?;846 p.eat(T![']'])?;847 parts.push(IndexPart {848 span: idx.span,849 value: idx.value,850 null_coaelse: true,851 });852 } else {853 854 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;855 parts.push(IndexPart {856 span: id_spanned.span,857 value: id_spanned.value,858 null_coaelse: true,859 });860 }861 } else {862 return Err(p.error("expected '.' after '?'".into()));863 }864 continue;865 }866867 if p.at(T![.]) {868 p.eat(T![.])?;869 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;870 parts.push(IndexPart {871 span: id_spanned.span,872 value: id_spanned.value,873 #[cfg(feature = "exp-null-coaelse")]874 null_coaelse: false,875 });876 } else if p.at(T!['[']) {877 p.eat(T!['['])?;878879 if p.at(T![:]) {880 881 flush_index_parts(&mut e, &mut parts);882 let slice = slice_desc(p, None)?;883 p.eat(T![']'])?;884 e = Expr::Slice(Box::new(Slice { value: e, slice }));885 } else {886 let idx = spanned(p, expr)?;887 if p.at(T![:]) {888 889 flush_index_parts(&mut e, &mut parts);890 let slice = slice_desc(p, Some(idx))?;891 p.eat(T![']'])?;892 e = Expr::Slice(Box::new(Slice { value: e, slice }));893 } else {894 895 p.eat(T![']'])?;896 parts.push(IndexPart {897 span: idx.span,898 value: idx.value,899 #[cfg(feature = "exp-null-coaelse")]900 null_coaelse: false,901 });902 }903 }904 } else if p.at(T!['(']) {905 flush_index_parts(&mut e, &mut parts);906 let args_spanned = spanned(p, |p| {907 p.eat(T!['('])?;908 let a = args(p)?;909 p.eat(T![')'])?;910 Ok(a)911 })?;912 let tailstrict = p.try_eat(T![tailstrict]);913 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);914 } else if p.at(T!['{']) {915 flush_index_parts(&mut e, &mut parts);916 p.eat(T!['{'])?;917 let body = objinside(p)?;918 p.eat(T!['}'])?;919 e = Expr::ObjExtend(Box::new(e), body);920 } else {921 break;922 }923 }924925 flush_index_parts(&mut e, &mut parts);926 Ok(e)927}928929fn prefix_binding_power(op: UnaryOpType) -> u8 {930 match op {931 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,932 }933}934935fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {936 match op {937 BinaryOpType::Or => (2, 3),938 #[cfg(feature = "exp-null-coaelse")]939 BinaryOpType::NullCoaelse => (2, 3),940 BinaryOpType::And => (4, 5),941 BinaryOpType::BitOr => (6, 7),942 BinaryOpType::BitXor => (8, 9),943 BinaryOpType::BitAnd => (10, 11),944 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),945 BinaryOpType::Lt946 | BinaryOpType::Gt947 | BinaryOpType::Lte948 | BinaryOpType::Gte949 | BinaryOpType::In => (14, 15),950 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),951 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),952 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),953 }954}955956fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {957 match kind {958 T![+] => Some(UnaryOpType::Plus),959 T![-] => Some(UnaryOpType::Minus),960 T![!] => Some(UnaryOpType::Not),961 T![~] => Some(UnaryOpType::BitNot),962 _ => None,963 }964}965966fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {967 match p.peek() {968 T![||] => Some(BinaryOpType::Or),969 T![&&] => Some(BinaryOpType::And),970 T![|] => Some(BinaryOpType::BitOr),971 T![^] => Some(BinaryOpType::BitXor),972 T![&] => Some(BinaryOpType::BitAnd),973 T![==] => Some(BinaryOpType::Eq),974 T![!=] => Some(BinaryOpType::Neq),975 T![<] => Some(BinaryOpType::Lt),976 T![>] => Some(BinaryOpType::Gt),977 T![<=] => Some(BinaryOpType::Lte),978 T![>=] => Some(BinaryOpType::Gte),979 T![<<] => Some(BinaryOpType::Lhs),980 T![>>] => Some(BinaryOpType::Rhs),981 T![+] => Some(BinaryOpType::Add),982 T![-] => Some(BinaryOpType::Sub),983 T![*] => Some(BinaryOpType::Mul),984 T![/] => Some(BinaryOpType::Div),985 T![%] => Some(BinaryOpType::Mod),986 T![in] => Some(BinaryOpType::In),987 #[cfg(feature = "exp-null-coaelse")]988 T![??] => Some(BinaryOpType::NullCoaelse),989 _ => None,990 }991}992993fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {994 let mut lhs = if let Some(op) = unary_op(p.peek()) {995 p.eat_any();996 let rbp = prefix_binding_power(op);997 let rhs = expr_bp(p, rbp)?;998 Expr::UnaryOp(op, Box::new(rhs))999 } else {1000 expr_suffix(p)?1001 };10021003 loop {1004 if p.at_eof() {1005 break;1006 }10071008 let Some(op) = binary_op(p) else {1009 break;1010 };10111012 let (lbp, rbp) = infix_binding_power(op);1013 if lbp < min_bp {1014 break;1015 }10161017 p.eat_any();1018 let rhs = expr_bp(p, rbp)?;1019 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1020 }10211022 Ok(lhs)1023}10241025fn expr(p: &mut Parser<'_>) -> Result<Expr> {1026 expr_bp(p, 0)1027}10281029pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1030 let mut p = Parser::new(str, settings.source.clone());1031 for lexeme in &p.lexemes {1032 if let Some(desc) = lexeme.kind.error_description() {1033 return Err(ParseError {1034 message: desc.to_owned(),1035 location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1036 });1037 }1038 }1039 let e = expr(&mut p)?;1040 if !p.at_eof() {1041 return Err(p.error(format!("expected end of file, got {}", p.current_desc())));1042 }1043 Ok(e)1044}10451046pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1047 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10481049 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1050}10511052#[cfg(test)]1053mod tests {1054 use insta::assert_snapshot;10551056 use super::*;10571058 fn parse_str(input: &str) -> Expr {1059 let source = Source::new_virtual("<test>".into(), input.into());1060 let settings = ParserSettings { source };1061 parse(input, &settings).unwrap()1062 }10631064 #[test]1065 #[cfg(not(feature = "exp-null-coaelse"))]1066 fn basic_test() {1067 let v = parse_str("assert true[false] : false ; true");1068 assert_snapshot!(format!("{v:#?}"));1069 }10701071 #[test]1072 fn literals() {1073 let v = parse_str("[null, true, false, self, super, $]");1074 assert_snapshot!(format!("{v:#?}"));1075 }10761077 #[test]1078 fn basic_math() {1079 let v = parse_str("2+2*2");1080 assert_snapshot!(format!("{v:#?}"));1081 }10821083 #[test]1084 fn underscore_numbers() {1085 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1086 assert_snapshot!(format!("{v:#?}"));1087 }10881089 #[test]1090 fn strings() {1091 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1092 assert_snapshot!(format!("{v:#?}"));1093 }10941095 #[test]1096 fn object() {1097 let v = parse_str("{a: 1, b:: 2, c::: 3}");1098 assert_snapshot!(format!("{v:#?}"));1099 }11001101 #[test]1102 fn function_and_call() {1103 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1104 assert_snapshot!(format!("{v:#?}"));1105 }11061107 #[test]1108 fn if_then_else() {1109 let v = parse_str("if true then 1 else 2");1110 assert_snapshot!(format!("{v:#?}"));1111 }11121113 #[test]1114 fn imports() {1115 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1116 assert_snapshot!(format!("{v:#?}"));1117 }11181119 #[test]1120 fn array_comp() {1121 let v = parse_str("[x for x in arr]");1122 assert_snapshot!(format!("{v:#?}"));1123 }11241125 #[test]1126 #[cfg(not(feature = "exp-null-coaelse"))]1127 fn index_and_suffix() {1128 let v = parse_str("std.test(2).field[0]");1129 assert_snapshot!(format!("{v:#?}"));1130 }11311132 #[test]1133 fn obj_extend() {1134 let v = parse_str("{} { x: 1 }");1135 assert_snapshot!(format!("{v:#?}"));1136 }11371138 #[test]1139 fn unary_ops() {1140 let v = parse_str("!a && !b");1141 assert_snapshot!(format!("{v:#?}"));1142 }11431144 #[test]1145 fn error_expr() {1146 let v = parse_str("error \"bad\"");1147 assert_snapshot!(format!("{v:#?}"));1148 }11491150 #[test]1151 fn slice() {1152 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1153 assert_snapshot!(format!("{v:#?}"));1154 }11551156 #[test]1157 #[cfg(not(feature = "exp-null-coaelse"))]1158 fn peg_snapshots() {1159 use std::fs;11601161 use insta::glob;1162 use jrsonnet_ir::{IStr, Source};11631164 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1165 let input = fs::read_to_string(path).expect("read test file");1166 let source = Source::new_virtual("<test>".into(), IStr::empty());1167 let settings = ParserSettings { source };1168 let v = parse(&input, &settings).unwrap();1169 let v = format!("{v:#?}");1170 assert_snapshot!(v);1171 });1172 }1173}