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 fn eat_any(&mut self) {70 self.offset += 1;71 }7273 fn at_eof(&self) -> bool {74 self.offset >= self.lexemes.len()75 }7677 fn try_eat(&mut self, t: SyntaxKind) -> bool {78 if self.at(t) {79 self.eat_any();80 return true;81 }82 false83 }8485 fn current_desc(&self) -> String {86 if self.at_eof() {87 return "end of file".to_owned();88 }89 let kind = self.peek();90 let text = self.text();91 let name = kind.display_name();92 if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {93 format!("{name} \"{text}\"")94 } else {95 name.to_owned()96 }97 }9899 fn eat(&mut self, t: SyntaxKind) -> Result<()> {100 if !self.at(t) {101 return Err(self.error(format!(102 "expected {}, got {}",103 t.display_name(),104 self.current_desc(),105 )));106 }107 self.eat_any();108 Ok(())109 }110111 fn span_start(&self) -> u32 {112 if self.at_eof() {113 if let Some(last) = self.lexemes.last() {114 return last.range.1;115 }116 return 0;117 }118 self.lexemes[self.offset].range.0119 }120121 fn span_end(&self) -> u32 {122 self.lexemes[self.offset - 1].range.1123 }124125 fn error(&self, message: String) -> ParseError {126 if self.offset == self.lexemes.len() {127 let pos = self.lexemes.last().map_or(0, |v| v.range.1);128 return ParseError {129 location: Span(self.source.clone(), pos, pos),130 message,131 };132 }133 let LexSpan(start, end) = self.lexemes[self.offset].range;134 ParseError {135 location: Span(self.source.clone(), start, end),136 message,137 }138 }139}140141fn spanned<T: Acyclic>(142 p: &mut Parser<'_>,143 cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,144) -> Result<Spanned<T>> {145 let start = p.span_start();146 let v = cb(p)?;147 let end = p.span_end();148 Ok(Spanned::new(v, Span(p.source.clone(), start, end)))149}150151fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {152 let kind = p.peek();153 let text = p.text();154 let s = match kind {155 SyntaxKind::STRING_DOUBLE => {156 let inner = &text[1..text.len() - 1];157 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?158 }159 SyntaxKind::STRING_SINGLE => {160 let inner = &text[1..text.len() - 1];161 unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?162 }163 SyntaxKind::STRING_DOUBLE_VERBATIM => {164 let inner = &text[2..text.len() - 1];165 inner.replace("\"\"", "\"")166 }167 SyntaxKind::STRING_SINGLE_VERBATIM => {168 let inner = &text[2..text.len() - 1];169 inner.replace("''", "'")170 }171 SyntaxKind::STRING_BLOCK => {172 let inner = &text[3..];173 let collected = collect_lexed_str_block(inner)174 .map_err(|_| p.error("invalid string block".into()))?;175 let mut result = String::new();176 for (i, line) in collected.lines.iter().enumerate() {177 if i > 0 {178 result.push('\n');179 }180 result.push_str(line);181 }182 if !collected.truncate {183 result.push('\n');184 }185 result186 }187 _ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),188 };189 p.eat_any();190 Ok(s.into())191}192193fn is_string_token(kind: SyntaxKind) -> bool {194 matches!(195 kind,196 SyntaxKind::STRING_DOUBLE197 | SyntaxKind::STRING_SINGLE198 | SyntaxKind::STRING_DOUBLE_VERBATIM199 | SyntaxKind::STRING_SINGLE_VERBATIM200 | SyntaxKind::STRING_BLOCK201 )202}203204fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {205 let text = p.text();206 let n: f64 = text207 .replace('_', "")208 .parse()209 .map_err(|_| p.error(format!("invalid number literal: {text}")))?;210211 let v = match NumValue::try_from(n) {212 Ok(v) => v,213 Err(e) => return Err(p.error(format!("invalid number value: {e}"))),214 };215216 p.eat_any();217218 Ok(v)219}220221fn ident(p: &mut Parser<'_>) -> Result<IStr> {222 let text = p.text();223 p.eat(SyntaxKind::IDENT)?;224 Ok(IStr::from(text))225}226227fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {228 let t = match p.peek() {229 T![self] => LiteralType::This,230 T![super] => LiteralType::Super,231 T!['$'] => LiteralType::Dollar,232 T![null] => LiteralType::Null,233 T![true] => LiteralType::True,234 T![false] => LiteralType::False,235 _ => return None,236 };237 p.eat_any();238 Some(t)239}240241fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {242 p.eat(T![assert])?;243 let assertion = spanned(p, expr)?;244 let message = if p.try_eat(T![:]) {245 Some(expr(p)?)246 } else {247 None248 };249 Ok(AssertStmt { assertion, message })250}251252fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {253 let v = spanned(p, |p| p.eat(T![if]))?;254 let cond = expr(p)?;255 Ok(IfSpecData { span: v.span, cond })256}257258fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {259 let cond = if_spec_data(p)?;260 p.eat(T![then])?;261 let cond_then = expr(p)?;262 let cond_else = if p.try_eat(T![else]) {263 Some(expr(p)?)264 } else {265 None266 };267 Ok(IfElse {268 cond,269 cond_then,270 cond_else,271 })272}273274fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {275 p.eat(T![:])?;276 let end = if !p.at(T![:]) && !p.at(T![']']) {277 Some(spanned(p, expr)?)278 } else {279 None280 };281 let step = if p.try_eat(T![:]) {282 if p.at(T![']']) {283 None284 } else {285 Some(spanned(p, expr)?)286 }287 } else {288 None289 };290 Ok(SliceDesc { start, end, step })291}292293fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {294 if p.at(SyntaxKind::IDENT) {295 return Ok(Destruct::Full(spanned(p, ident)?));296 }297 #[cfg(not(feature = "exp-destruct"))]298 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));299 #[cfg(feature = "exp-destruct")]300 {301 if p.try_eat(T![?]) {302 return Ok(Destruct::Skip);303 }304 if p.at(T!['[']) {305 return destruct_array(p);306 }307 if p.at(T!['{']) {308 return destruct_object(p);309 }310 Err(p.error(format!(311 "expected destructure pattern, got {}",312 p.current_desc()313 )))314 }315}316317#[cfg(feature = "exp-destruct")]318fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {319 p.eat(T![...])?;320 if p.at(SyntaxKind::IDENT) {321 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))322 } else {323 Ok(jrsonnet_ir::DestructRest::Drop)324 }325}326327#[cfg(feature = "exp-destruct")]328fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {329 p.eat(T!['['])?;330 let mut start = Vec::new();331 let mut rest = None;332 let mut end = Vec::new();333 if !p.at(T![']']) {334 loop {335 if p.at(T![...]) {336 rest = Some(destruct_rest(p)?);337 if p.try_eat(T![,]) {338 if !p.at(T![']']) {339 loop {340 end.push(destruct(p)?);341 if !p.try_eat(T![,]) {342 break;343 }344 if p.at(T![']']) {345 break;346 }347 }348 }349 }350 break;351 }352 start.push(destruct(p)?);353 if !p.try_eat(T![,]) {354 break;355 }356 if p.at(T![']']) {357 break;358 }359 }360 }361 p.eat(T![']'])?;362 Ok(Destruct::Array { start, rest, end })363}364365#[cfg(feature = "exp-destruct")]366fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {367 p.eat(T!['{'])?;368 let mut fields = Vec::new();369 let mut rest = None;370 if !p.at(T!['}']) {371 loop {372 if p.at(T![...]) {373 rest = Some(destruct_rest(p)?);374 p.try_eat(T![,]);375 break;376 }377 let name = ident(p)?;378 let into = if p.try_eat(T![:]) {379 Some(destruct(p)?)380 } else {381 None382 };383 let default = if p.try_eat(T![=]) {384 Some(spanned(p, expr)?)385 } else {386 None387 };388 fields.push((name, into, default));389 if !p.try_eat(T![,]) {390 break;391 }392 if p.at(T!['}']) {393 break;394 }395 }396 }397 p.eat(T!['}'])?;398 Ok(Destruct::Object { fields, rest })399}400401fn params(p: &mut Parser<'_>) -> Result<ExprParams> {402 if p.at(T![')']) {403 return Ok(ExprParams::new(Vec::new()));404 }405 let mut result = Vec::new();406 loop {407 let d = destruct(p)?;408 let default = if p.try_eat(T![=]) {409 Some(expr(p)?)410 } else {411 None412 };413 result.push(ExprParam {414 destruct: d,415 default,416 });417 if !p.try_eat(T![,]) {418 break;419 }420 if p.at(T![')']) {421 break;422 }423 }424 Ok(ExprParams::new(result))425}426427fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {428 if p.at(T![')']) {429 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));430 }431 let mut unnamed = Vec::new();432 let mut names = Vec::new();433 let mut values = Vec::new();434 let mut named_started = false;435 loop {436 let is_named = p.at(SyntaxKind::IDENT) && {437 let next_offset = p.offset + 1;438 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]439 };440 if is_named {441 let name: IStr = ident(p)?;442 p.eat(T![=])?;443444 names.push(name);445 values.push(expr(p)?);446 named_started = true;447 } else {448 if named_started {449 return Err(p.error("positional argument after named argument".into()));450 }451 unnamed.push(expr(p)?);452 }453 if !p.try_eat(T![,]) {454 break;455 }456 if p.at(T![')']) {457 break;458 }459 }460 Ok(ArgsDesc::new(unnamed, names, values))461}462463fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {464 #[cfg(feature = "exp-destruct")]465 {466 if !p.at(SyntaxKind::IDENT) {467 let d = destruct(p)?;468 p.eat(T![=])?;469 return Ok(BindSpec::Field {470 into: d,471 value: expr(p)?,472 });473 }474 }475 let name_spanned = spanned(p, ident)?;476 if p.try_eat(T!['(']) {477 let ps = params(p)?;478 p.eat(T![')'])?;479 p.eat(T![=])?;480 Ok(BindSpec::Function {481 name: name_spanned.value,482 params: ps,483 value: expr(p)?,484 })485 } else {486 p.eat(T![=])?;487 Ok(BindSpec::Field {488 into: Destruct::Full(name_spanned),489 value: expr(p)?,490 })491 }492}493494fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {495 p.eat(T![:])?;496 if p.try_eat(T![:]) {497 if p.try_eat(T![:]) {498 Ok(Visibility::Unhide)499 } else {500 Ok(Visibility::Hidden)501 }502 } else {503 Ok(Visibility::Normal)504 }505}506507fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {508 if p.at(SyntaxKind::IDENT) {509 Ok(FieldName::Fixed(ident(p)?))510 } else if is_string_token(p.peek()) {511 Ok(FieldName::Fixed(parse_string_content(p)?))512 } else if p.at(T!['[']) {513 p.eat(T!['['])?;514 let e = expr(p)?;515 p.eat(T![']'])?;516 Ok(FieldName::Dyn(e))517 } else {518 Err(p.error(format!("expected field name, got {}", p.current_desc())))519 }520}521522fn field(p: &mut Parser<'_>) -> Result<FieldMember> {523 let name = spanned(p, field_name)?;524525 if p.at(T!['(']) {526 p.eat(T!['('])?;527 let ps = params(p)?;528 p.eat(T![')'])?;529 let vis = visibility(p)?;530 Ok(FieldMember {531 name,532 plus: false,533 params: Some(ps),534 visibility: vis,535 value: expr(p)?,536 })537 } else {538 let plus = p.try_eat(T![+]);539 let vis = visibility(p)?;540 Ok(FieldMember {541 name,542 plus,543 params: None,544 visibility: vis,545 value: expr(p)?,546 })547 }548}549550fn member(p: &mut Parser<'_>) -> Result<Member> {551 if p.at(T![local]) {552 p.eat(T![local])?;553 Ok(Member::BindStmt(bind(p)?))554 } else if p.at(T![assert]) {555 Ok(Member::AssertStmt(assert_stmt(p)?))556 } else {557 Ok(Member::Field(field(p)?))558 }559}560561fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {562 p.eat(T![for])?;563 let d = destruct(p)?;564 p.eat(T![in])?;565 let over = expr(p)?;566 Ok(ForSpecData { destruct: d, over })567}568569fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {570 let mut specs = Vec::new();571 specs.push(CompSpec::ForSpec(for_spec(p)?));572 loop {573 if p.at(T![for]) {574 specs.push(CompSpec::ForSpec(for_spec(p)?));575 } else if p.at(T![if]) {576 let isd = if_spec_data(p)?;577 specs.push(CompSpec::IfSpec(isd));578 } else {579 break;580 }581 }582 Ok(specs)583}584585fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {586 if p.at(T!['}']) {587 return Ok(ObjBody::MemberList(ObjMembers {588 locals: Vec::new(),589 asserts: Vec::new(),590 fields: Vec::new(),591 }));592 }593594 let mut members = Vec::new();595 loop {596 members.push(member(p)?);597 if !p.try_eat(T![,]) {598 break;599 }600 if p.at(T!['}']) || p.at(T![for]) {601 break;602 }603 }604605 if p.at(T![for]) {606 let specs = compspecs(p)?;607 let mut locals = Vec::new();608 let mut field_member = None;609 for m in members {610 match m {611 Member::Field(f) => {612 if field_member.is_some() {613 return Err(614 p.error("object comprehension can only contain one field".into())615 );616 }617 field_member = Some(f);618 }619 Member::BindStmt(b) => locals.push(b),620 Member::AssertStmt(_) => {621 return Err(p.error("asserts are unsupported in object comprehension".into()));622 }623 }624 }625 Ok(ObjBody::ObjComp(ObjComp {626 locals,627 field: Box::new(628 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,629 ),630 compspecs: specs,631 }))632 } else {633 let mut locals = Vec::new();634 let mut asserts = Vec::new();635 let mut fields = Vec::new();636 for m in members {637 match m {638 Member::Field(f) => fields.push(f),639 Member::BindStmt(b) => locals.push(b),640 Member::AssertStmt(a) => asserts.push(a),641 }642 }643 Ok(ObjBody::MemberList(ObjMembers {644 locals,645 asserts,646 fields,647 }))648 }649}650651#[allow(clippy::too_many_lines)]652fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {653 if let Some(lit) = literal(p) {654 return Ok(Expr::Literal(lit));655 }656657 match p.peek() {658 SyntaxKind::STRING_DOUBLE659 | SyntaxKind::STRING_SINGLE660 | SyntaxKind::STRING_DOUBLE_VERBATIM661 | SyntaxKind::STRING_SINGLE_VERBATIM662 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),663664 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),665666 T!['('] => {667 p.eat(T!['('])?;668 let e = expr(p)?;669 p.eat(T![')'])?;670 Ok(e)671 }672673 T!['['] => {674 p.eat(T!['['])?;675 if p.at(T![']']) {676 p.eat(T![']'])?;677 return Ok(Expr::Arr(Vec::new()));678 }679 let first = expr(p)?;680 if p.at(T![for]) {681 let specs = compspecs(p)?;682 p.eat(T![']'])?;683 Ok(Expr::ArrComp(Box::new(first), specs))684 } else if p.at(T![,]) && {685 let next = p.offset + 1;686 next < p.lexemes.len() && p.lexemes[next].kind == T![for]687 } {688 p.eat(T![,])?;689 let specs = compspecs(p)?;690 p.eat(T![']'])?;691 Ok(Expr::ArrComp(Box::new(first), specs))692 } else {693 let mut elems = vec![first];694 while p.try_eat(T![,]) {695 if p.at(T![']']) {696 break;697 }698 elems.push(expr(p)?);699 }700 p.eat(T![']'])?;701 Ok(Expr::Arr(elems))702 }703 }704705 T!['{'] => {706 p.eat(T!['{'])?;707 let body = objinside(p)?;708 p.eat(T!['}'])?;709 Ok(Expr::Obj(body))710 }711712 T![local] => {713 p.eat(T![local])?;714 let mut binds = Vec::new();715 loop {716 if p.at(T![;]) {717 break;718 }719 binds.push(bind(p)?);720 if !p.try_eat(T![,]) {721 break;722 }723 }724 p.eat(T![;])?;725 let body = expr(p)?;726 Ok(Expr::LocalExpr(binds, Box::new(body)))727 }728729 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),730731 T![function] => {732 p.eat(T![function])?;733 p.eat(T!['('])?;734 let ps = params(p)?;735 p.eat(T![')'])?;736 let body = expr(p)?;737 Ok(Expr::Function(ps, Box::new(body)))738 }739740 T![assert] => {741 let a = assert_stmt(p)?;742 p.eat(T![;])?;743 let rest = expr(p)?;744 Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))745 }746747 T![error] => {748 let span = spanned(p, |p| p.eat(T![error]))?;749 let e = expr(p)?;750 Ok(Expr::ErrorStmt(span.span, Box::new(e)))751 }752753 T![importstr] => {754 let kind = spanned(p, |p| {755 p.eat(T![importstr])?;756 Ok(ImportKind::Str)757 })?;758 let path = expr(p)?;759 Ok(Expr::Import(kind, Box::new(path)))760 }761762 T![importbin] => {763 let kind = spanned(p, |p| {764 p.eat(T![importbin])?;765 Ok(ImportKind::Bin)766 })?;767 let path = expr(p)?;768 Ok(Expr::Import(kind, Box::new(path)))769 }770771 T![import] => {772 let kind = spanned(p, |p| {773 p.eat(T![import])?;774 Ok(ImportKind::Normal)775 })?;776 let path = expr(p)?;777 Ok(Expr::Import(kind, Box::new(path)))778 }779780 SyntaxKind::IDENT => {781 let n = spanned(p, |p| {782 let s: IStr = p.text().into();783 p.eat_any();784 Ok(s)785 })?;786 Ok(Expr::Var(n))787 }788789 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),790 }791}792793fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {794 if parts.is_empty() {795 return;796 }797 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));798 *e = Expr::Index {799 indexable: Box::new(old),800 parts: std::mem::take(parts),801 };802}803804fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {805 let mut e = expr_basic(p)?;806 807 808 809 let mut parts: Vec<IndexPart> = Vec::new();810811 loop {812 #[cfg(feature = "exp-null-coaelse")]813 if p.at(T![?]) {814 p.eat_any();815 if p.try_eat(T![.]) {816 if p.at(T!['[']) {817 818 p.eat(T!['['])?;819 let idx = spanned(p, expr)?;820 p.eat(T![']'])?;821 parts.push(IndexPart {822 span: idx.span,823 value: idx.value,824 null_coaelse: true,825 });826 } else {827 828 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;829 parts.push(IndexPart {830 span: id_spanned.span,831 value: id_spanned.value,832 null_coaelse: true,833 });834 }835 } else {836 return Err(p.error("expected '.' after '?'".into()));837 }838 continue;839 }840841 if p.at(T![.]) {842 p.eat(T![.])?;843 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;844 parts.push(IndexPart {845 span: id_spanned.span,846 value: id_spanned.value,847 #[cfg(feature = "exp-null-coaelse")]848 null_coaelse: false,849 });850 } else if p.at(T!['[']) {851 p.eat(T!['['])?;852853 if p.at(T![:]) {854 855 flush_index_parts(&mut e, &mut parts);856 let slice = slice_desc(p, None)?;857 p.eat(T![']'])?;858 e = Expr::Slice(Box::new(Slice { value: e, slice }));859 } else {860 let idx = spanned(p, expr)?;861 if p.at(T![:]) {862 863 flush_index_parts(&mut e, &mut parts);864 let slice = slice_desc(p, Some(idx))?;865 p.eat(T![']'])?;866 e = Expr::Slice(Box::new(Slice { value: e, slice }));867 } else {868 869 p.eat(T![']'])?;870 parts.push(IndexPart {871 span: idx.span,872 value: idx.value,873 #[cfg(feature = "exp-null-coaelse")]874 null_coaelse: false,875 });876 }877 }878 } else if p.at(T!['(']) {879 flush_index_parts(&mut e, &mut parts);880 let args_spanned = spanned(p, |p| {881 p.eat(T!['('])?;882 let a = args(p)?;883 p.eat(T![')'])?;884 Ok(a)885 })?;886 let tailstrict = p.try_eat(T![tailstrict]);887 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);888 } else if p.at(T!['{']) {889 flush_index_parts(&mut e, &mut parts);890 p.eat(T!['{'])?;891 let body = objinside(p)?;892 p.eat(T!['}'])?;893 e = Expr::ObjExtend(Box::new(e), body);894 } else {895 break;896 }897 }898899 flush_index_parts(&mut e, &mut parts);900 Ok(e)901}902903fn prefix_binding_power(op: UnaryOpType) -> u8 {904 match op {905 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,906 }907}908909fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {910 match op {911 BinaryOpType::Or => (2, 3),912 #[cfg(feature = "exp-null-coaelse")]913 BinaryOpType::NullCoaelse => (2, 3),914 BinaryOpType::And => (4, 5),915 BinaryOpType::BitOr => (6, 7),916 BinaryOpType::BitXor => (8, 9),917 BinaryOpType::BitAnd => (10, 11),918 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),919 BinaryOpType::Lt920 | BinaryOpType::Gt921 | BinaryOpType::Lte922 | BinaryOpType::Gte923 | BinaryOpType::In => (14, 15),924 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),925 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),926 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),927 }928}929930fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {931 match kind {932 T![+] => Some(UnaryOpType::Plus),933 T![-] => Some(UnaryOpType::Minus),934 T![!] => Some(UnaryOpType::Not),935 T![~] => Some(UnaryOpType::BitNot),936 _ => None,937 }938}939940fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {941 match p.peek() {942 T![||] => Some(BinaryOpType::Or),943 T![&&] => Some(BinaryOpType::And),944 T![|] => Some(BinaryOpType::BitOr),945 T![^] => Some(BinaryOpType::BitXor),946 T![&] => Some(BinaryOpType::BitAnd),947 T![==] => Some(BinaryOpType::Eq),948 T![!=] => Some(BinaryOpType::Neq),949 T![<] => Some(BinaryOpType::Lt),950 T![>] => Some(BinaryOpType::Gt),951 T![<=] => Some(BinaryOpType::Lte),952 T![>=] => Some(BinaryOpType::Gte),953 T![<<] => Some(BinaryOpType::Lhs),954 T![>>] => Some(BinaryOpType::Rhs),955 T![+] => Some(BinaryOpType::Add),956 T![-] => Some(BinaryOpType::Sub),957 T![*] => Some(BinaryOpType::Mul),958 T![/] => Some(BinaryOpType::Div),959 T![%] => Some(BinaryOpType::Mod),960 T![in] => Some(BinaryOpType::In),961 #[cfg(feature = "exp-null-coaelse")]962 T![??] => Some(BinaryOpType::NullCoaelse),963 _ => None,964 }965}966967fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {968 let mut lhs = if let Some(op) = unary_op(p.peek()) {969 p.eat_any();970 let rbp = prefix_binding_power(op);971 let rhs = expr_bp(p, rbp)?;972 Expr::UnaryOp(op, Box::new(rhs))973 } else {974 expr_suffix(p)?975 };976977 loop {978 if p.at_eof() {979 break;980 }981982 let Some(op) = binary_op(p) else {983 break;984 };985986 let (lbp, rbp) = infix_binding_power(op);987 if lbp < min_bp {988 break;989 }990991 p.eat_any();992 let rhs = expr_bp(p, rbp)?;993 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));994 }995996 Ok(lhs)997}998999fn expr(p: &mut Parser<'_>) -> Result<Expr> {1000 expr_bp(p, 0)1001}10021003pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1004 let mut p = Parser::new(str, settings.source.clone());1005 for lexeme in &p.lexemes {1006 if let Some(desc) = lexeme.kind.error_description() {1007 return Err(ParseError {1008 message: desc.to_owned(),1009 location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1010 });1011 }1012 }1013 let e = expr(&mut p)?;1014 if !p.at_eof() {1015 return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1016 }1017 Ok(e)1018}10191020pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1021 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10221023 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1024}10251026#[cfg(test)]1027mod tests {1028 use std::fs;10291030 use insta::{assert_snapshot, glob};1031 use jrsonnet_ir::{IStr, Source};10321033 use super::*;10341035 fn parse_str(input: &str) -> Expr {1036 let source = Source::new_virtual("<test>".into(), input.into());1037 let settings = ParserSettings { source };1038 parse(input, &settings).unwrap()1039 }10401041 #[test]1042 #[cfg(not(feature = "exp-null-coaelse"))]1043 fn basic_test() {1044 let v = parse_str("assert true[false] : false ; true");1045 assert_snapshot!(format!("{v:#?}"));1046 }10471048 #[test]1049 fn literals() {1050 let v = parse_str("[null, true, false, self, super, $]");1051 assert_snapshot!(format!("{v:#?}"));1052 }10531054 #[test]1055 fn basic_math() {1056 let v = parse_str("2+2*2");1057 assert_snapshot!(format!("{v:#?}"));1058 }10591060 #[test]1061 fn underscore_numbers() {1062 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1063 assert_snapshot!(format!("{v:#?}"));1064 }10651066 #[test]1067 fn strings() {1068 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1069 assert_snapshot!(format!("{v:#?}"));1070 }10711072 #[test]1073 fn object() {1074 let v = parse_str("{a: 1, b:: 2, c::: 3}");1075 assert_snapshot!(format!("{v:#?}"));1076 }10771078 #[test]1079 fn function_and_call() {1080 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1081 assert_snapshot!(format!("{v:#?}"));1082 }10831084 #[test]1085 fn if_then_else() {1086 let v = parse_str("if true then 1 else 2");1087 assert_snapshot!(format!("{v:#?}"));1088 }10891090 #[test]1091 fn imports() {1092 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1093 assert_snapshot!(format!("{v:#?}"));1094 }10951096 #[test]1097 fn array_comp() {1098 let v = parse_str("[x for x in arr]");1099 assert_snapshot!(format!("{v:#?}"));1100 }11011102 #[test]1103 #[cfg(not(feature = "exp-null-coaelse"))]1104 fn index_and_suffix() {1105 let v = parse_str("std.test(2).field[0]");1106 assert_snapshot!(format!("{v:#?}"));1107 }11081109 #[test]1110 fn obj_extend() {1111 let v = parse_str("{} { x: 1 }");1112 assert_snapshot!(format!("{v:#?}"));1113 }11141115 #[test]1116 fn unary_ops() {1117 let v = parse_str("!a && !b");1118 assert_snapshot!(format!("{v:#?}"));1119 }11201121 #[test]1122 fn error_expr() {1123 let v = parse_str("error \"bad\"");1124 assert_snapshot!(format!("{v:#?}"));1125 }11261127 #[test]1128 fn slice() {1129 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1130 assert_snapshot!(format!("{v:#?}"));1131 }11321133 #[test]1134 #[cfg(not(feature = "exp-null-coaelse"))]1135 fn peg_snapshots() {1136 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1137 let input = fs::read_to_string(path).expect("read test file");1138 let source = Source::new_virtual("<test>".into(), IStr::empty());1139 let settings = ParserSettings { source };1140 let v = parse(&input, &settings).unwrap();1141 let v = format!("{v:#?}");1142 assert_snapshot!(v);1143 });1144 }1145}