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 if !p.at(SyntaxKind::IDENT) {223 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));224 }225 let text = p.text();226 p.eat_any();227 Ok(IStr::from(text))228}229230fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {231 let t = match p.peek() {232 T![self] => LiteralType::This,233 T![super] => LiteralType::Super,234 T!['$'] => LiteralType::Dollar,235 T![null] => LiteralType::Null,236 T![true] => LiteralType::True,237 T![false] => LiteralType::False,238 _ => return None,239 };240 p.eat_any();241 Some(t)242}243244fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {245 p.eat(T![assert])?;246 let assertion = spanned(p, expr)?;247 let message = if p.try_eat(T![:]) {248 Some(expr(p)?)249 } else {250 None251 };252 Ok(AssertStmt { assertion, message })253}254255fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {256 let v = spanned(p, |p| p.eat(T![if]))?;257 let cond = expr(p)?;258 Ok(IfSpecData { span: v.span, cond })259}260261fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {262 let cond = if_spec_data(p)?;263 p.eat(T![then])?;264 let cond_then = expr(p)?;265 let cond_else = if p.try_eat(T![else]) {266 Some(expr(p)?)267 } else {268 None269 };270 Ok(IfElse {271 cond,272 cond_then,273 cond_else,274 })275}276277fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {278 p.eat(T![:])?;279 let end = if !p.at(T![:]) && !p.at(T![']']) {280 Some(spanned(p, expr)?)281 } else {282 None283 };284 let step = if p.try_eat(T![:]) {285 if p.at(T![']']) {286 None287 } else {288 Some(spanned(p, expr)?)289 }290 } else {291 None292 };293 Ok(SliceDesc { start, end, step })294}295296fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {297 if p.at(SyntaxKind::IDENT) {298 return Ok(Destruct::Full(spanned(p, ident)?));299 }300 #[cfg(not(feature = "exp-destruct"))]301 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));302 #[cfg(feature = "exp-destruct")]303 {304 if p.try_eat(T![?]) {305 return Ok(Destruct::Skip);306 }307 if p.at(T!['[']) {308 return destruct_array(p);309 }310 if p.at(T!['{']) {311 return destruct_object(p);312 }313 Err(p.error(format!(314 "expected destructure pattern, got {}",315 p.current_desc()316 )))317 }318}319320#[cfg(feature = "exp-destruct")]321fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {322 p.eat(T![...])?;323 if p.at(SyntaxKind::IDENT) {324 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))325 } else {326 Ok(jrsonnet_ir::DestructRest::Drop)327 }328}329330#[cfg(feature = "exp-destruct")]331fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {332 p.eat(T!['['])?;333 let mut start = Vec::new();334 let mut rest = None;335 let mut end = Vec::new();336 if !p.at(T![']']) {337 loop {338 if p.at(T![...]) {339 rest = Some(destruct_rest(p)?);340 if p.try_eat(T![,]) {341 if !p.at(T![']']) {342 loop {343 end.push(destruct(p)?);344 if !p.try_eat(T![,]) {345 break;346 }347 if p.at(T![']']) {348 break;349 }350 }351 }352 }353 break;354 }355 start.push(destruct(p)?);356 if !p.try_eat(T![,]) {357 break;358 }359 if p.at(T![']']) {360 break;361 }362 }363 }364 p.eat(T![']'])?;365 Ok(Destruct::Array { start, rest, end })366}367368#[cfg(feature = "exp-destruct")]369fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {370 p.eat(T!['{'])?;371 let mut fields = Vec::new();372 let mut rest = None;373 if !p.at(T!['}']) {374 loop {375 if p.at(T![...]) {376 rest = Some(destruct_rest(p)?);377 p.try_eat(T![,]);378 break;379 }380 let name = ident(p)?;381 let into = if p.try_eat(T![:]) {382 Some(destruct(p)?)383 } else {384 None385 };386 let default = if p.try_eat(T![=]) {387 Some(spanned(p, expr)?)388 } else {389 None390 };391 fields.push((name, into, default));392 if !p.try_eat(T![,]) {393 break;394 }395 if p.at(T!['}']) {396 break;397 }398 }399 }400 p.eat(T!['}'])?;401 Ok(Destruct::Object { fields, rest })402}403404fn params(p: &mut Parser<'_>) -> Result<ExprParams> {405 if p.at(T![')']) {406 return Ok(ExprParams::new(Vec::new()));407 }408 let mut result = Vec::new();409 loop {410 let d = destruct(p)?;411 let default = if p.try_eat(T![=]) {412 Some(expr(p)?)413 } else {414 None415 };416 result.push(ExprParam {417 destruct: d,418 default,419 });420 if !p.try_eat(T![,]) {421 break;422 }423 if p.at(T![')']) {424 break;425 }426 }427 Ok(ExprParams::new(result))428}429430fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {431 if p.at(T![')']) {432 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));433 }434 let mut unnamed = Vec::new();435 let mut names = Vec::new();436 let mut values = Vec::new();437 let mut named_started = false;438 loop {439 let is_named = p.at(SyntaxKind::IDENT) && {440 let next_offset = p.offset + 1;441 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]442 };443 if is_named {444 let name: IStr = ident(p)?;445 p.eat(T![=])?;446447 names.push(name);448 values.push(expr(p)?);449 named_started = true;450 } else {451 if named_started {452 return Err(p.error("positional argument after named argument".into()));453 }454 unnamed.push(expr(p)?);455 }456 if !p.try_eat(T![,]) {457 break;458 }459 if p.at(T![')']) {460 break;461 }462 }463 Ok(ArgsDesc::new(unnamed, names, values))464}465466fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {467 #[cfg(feature = "exp-destruct")]468 {469 if !p.at(SyntaxKind::IDENT) {470 let d = destruct(p)?;471 p.eat(T![=])?;472 return Ok(BindSpec::Field {473 into: d,474 value: expr(p)?,475 });476 }477 }478 let name_spanned = spanned(p, ident)?;479 if p.try_eat(T!['(']) {480 let ps = params(p)?;481 p.eat(T![')'])?;482 p.eat(T![=])?;483 Ok(BindSpec::Function {484 name: name_spanned.value,485 params: ps,486 value: expr(p)?,487 })488 } else {489 p.eat(T![=])?;490 Ok(BindSpec::Field {491 into: Destruct::Full(name_spanned),492 value: expr(p)?,493 })494 }495}496497fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {498 p.eat(T![:])?;499 if p.try_eat(T![:]) {500 if p.try_eat(T![:]) {501 Ok(Visibility::Unhide)502 } else {503 Ok(Visibility::Hidden)504 }505 } else {506 Ok(Visibility::Normal)507 }508}509510fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {511 if p.at(SyntaxKind::IDENT) {512 Ok(FieldName::Fixed(ident(p)?))513 } else if is_string_token(p.peek()) {514 Ok(FieldName::Fixed(parse_string_content(p)?))515 } else if p.at(T!['[']) {516 p.eat(T!['['])?;517 let e = expr(p)?;518 p.eat(T![']'])?;519 Ok(FieldName::Dyn(e))520 } else {521 Err(p.error(format!("expected field name, got {}", p.current_desc())))522 }523}524525fn field(p: &mut Parser<'_>) -> Result<FieldMember> {526 let name = spanned(p, field_name)?;527528 if p.at(T!['(']) {529 p.eat(T!['('])?;530 let ps = params(p)?;531 p.eat(T![')'])?;532 let vis = visibility(p)?;533 Ok(FieldMember {534 name,535 plus: false,536 params: Some(ps),537 visibility: vis,538 value: expr(p)?,539 })540 } else {541 let plus = p.try_eat(T![+]);542 let vis = visibility(p)?;543 Ok(FieldMember {544 name,545 plus,546 params: None,547 visibility: vis,548 value: expr(p)?,549 })550 }551}552553fn member(p: &mut Parser<'_>) -> Result<Member> {554 if p.at(T![local]) {555 p.eat(T![local])?;556 Ok(Member::BindStmt(bind(p)?))557 } else if p.at(T![assert]) {558 Ok(Member::AssertStmt(assert_stmt(p)?))559 } else {560 Ok(Member::Field(field(p)?))561 }562}563564fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {565 p.eat(T![for])?;566 let d = destruct(p)?;567 p.eat(T![in])?;568 let over = expr(p)?;569 Ok(ForSpecData { destruct: d, over })570}571572fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {573 let mut specs = Vec::new();574 specs.push(CompSpec::ForSpec(for_spec(p)?));575 loop {576 if p.at(T![for]) {577 specs.push(CompSpec::ForSpec(for_spec(p)?));578 } else if p.at(T![if]) {579 let isd = if_spec_data(p)?;580 specs.push(CompSpec::IfSpec(isd));581 } else {582 break;583 }584 }585 Ok(specs)586}587588fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {589 if p.at(T!['}']) {590 return Ok(ObjBody::MemberList(ObjMembers {591 locals: Vec::new(),592 asserts: Vec::new(),593 fields: Vec::new(),594 }));595 }596597 let mut members = Vec::new();598 loop {599 members.push(member(p)?);600 if !p.try_eat(T![,]) {601 break;602 }603 if p.at(T!['}']) || p.at(T![for]) {604 break;605 }606 }607608 if p.at(T![for]) {609 let specs = compspecs(p)?;610 let mut locals = Vec::new();611 let mut field_member = None;612 for m in members {613 match m {614 Member::Field(f) => {615 if field_member.is_some() {616 return Err(617 p.error("object comprehension can only contain one field".into())618 );619 }620 field_member = Some(f);621 }622 Member::BindStmt(b) => locals.push(b),623 Member::AssertStmt(_) => {624 return Err(p.error("asserts are unsupported in object comprehension".into()));625 }626 }627 }628 Ok(ObjBody::ObjComp(ObjComp {629 locals,630 field: Box::new(631 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,632 ),633 compspecs: specs,634 }))635 } else {636 let mut locals = Vec::new();637 let mut asserts = Vec::new();638 let mut fields = Vec::new();639 for m in members {640 match m {641 Member::Field(f) => fields.push(f),642 Member::BindStmt(b) => locals.push(b),643 Member::AssertStmt(a) => asserts.push(a),644 }645 }646 Ok(ObjBody::MemberList(ObjMembers {647 locals,648 asserts,649 fields,650 }))651 }652}653654#[allow(clippy::too_many_lines)]655fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {656 if let Some(lit) = literal(p) {657 return Ok(Expr::Literal(lit));658 }659660 match p.peek() {661 SyntaxKind::STRING_DOUBLE662 | SyntaxKind::STRING_SINGLE663 | SyntaxKind::STRING_DOUBLE_VERBATIM664 | SyntaxKind::STRING_SINGLE_VERBATIM665 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),666667 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),668669 T!['('] => {670 p.eat(T!['('])?;671 let e = expr(p)?;672 p.eat(T![')'])?;673 Ok(e)674 }675676 T!['['] => {677 p.eat(T!['['])?;678 if p.at(T![']']) {679 p.eat(T![']'])?;680 return Ok(Expr::Arr(Vec::new()));681 }682 let first = expr(p)?;683 if p.at(T![for]) {684 let specs = compspecs(p)?;685 p.eat(T![']'])?;686 Ok(Expr::ArrComp(Box::new(first), specs))687 } else if p.at(T![,]) && {688 let next = p.offset + 1;689 next < p.lexemes.len() && p.lexemes[next].kind == T![for]690 } {691 p.eat(T![,])?;692 let specs = compspecs(p)?;693 p.eat(T![']'])?;694 Ok(Expr::ArrComp(Box::new(first), specs))695 } else {696 let mut elems = vec![first];697 while p.try_eat(T![,]) {698 if p.at(T![']']) {699 break;700 }701 elems.push(expr(p)?);702 }703 p.eat(T![']'])?;704 Ok(Expr::Arr(elems))705 }706 }707708 T!['{'] => {709 p.eat(T!['{'])?;710 let body = objinside(p)?;711 p.eat(T!['}'])?;712 Ok(Expr::Obj(body))713 }714715 T![local] => {716 p.eat(T![local])?;717 let mut binds = Vec::new();718 loop {719 if p.at(T![;]) {720 break;721 }722 binds.push(bind(p)?);723 if !p.try_eat(T![,]) {724 break;725 }726 }727 p.eat(T![;])?;728 let body = expr(p)?;729 Ok(Expr::LocalExpr(binds, Box::new(body)))730 }731732 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),733734 T![function] => {735 p.eat(T![function])?;736 p.eat(T!['('])?;737 let ps = params(p)?;738 p.eat(T![')'])?;739 let body = expr(p)?;740 Ok(Expr::Function(ps, Box::new(body)))741 }742743 T![assert] => {744 let a = assert_stmt(p)?;745 p.eat(T![;])?;746 let rest = expr(p)?;747 Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))748 }749750 T![error] => {751 let span = spanned(p, |p| p.eat(T![error]))?;752 let e = expr(p)?;753 Ok(Expr::ErrorStmt(span.span, Box::new(e)))754 }755756 T![importstr] => {757 let kind = spanned(p, |p| {758 p.eat(T![importstr])?;759 Ok(ImportKind::Str)760 })?;761 let path = expr(p)?;762 Ok(Expr::Import(kind, Box::new(path)))763 }764765 T![importbin] => {766 let kind = spanned(p, |p| {767 p.eat(T![importbin])?;768 Ok(ImportKind::Bin)769 })?;770 let path = expr(p)?;771 Ok(Expr::Import(kind, Box::new(path)))772 }773774 T![import] => {775 let kind = spanned(p, |p| {776 p.eat(T![import])?;777 Ok(ImportKind::Normal)778 })?;779 let path = expr(p)?;780 Ok(Expr::Import(kind, Box::new(path)))781 }782783 SyntaxKind::IDENT => {784 let n = spanned(p, |p| {785 let s: IStr = p.text().into();786 p.eat_any();787 Ok(s)788 })?;789 Ok(Expr::Var(n))790 }791792 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),793 }794}795796fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {797 if parts.is_empty() {798 return;799 }800 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));801 *e = Expr::Index {802 indexable: Box::new(old),803 parts: std::mem::take(parts),804 };805}806807fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {808 let mut e = expr_basic(p)?;809 810 811 812 let mut parts: Vec<IndexPart> = Vec::new();813814 loop {815 #[cfg(feature = "exp-null-coaelse")]816 if p.at(T![?]) {817 p.eat_any();818 if p.try_eat(T![.]) {819 if p.at(T!['[']) {820 821 p.eat(T!['['])?;822 let idx = spanned(p, expr)?;823 p.eat(T![']'])?;824 parts.push(IndexPart {825 span: idx.span,826 value: idx.value,827 null_coaelse: true,828 });829 } else {830 831 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;832 parts.push(IndexPart {833 span: id_spanned.span,834 value: id_spanned.value,835 null_coaelse: true,836 });837 }838 } else {839 return Err(p.error("expected '.' after '?'".into()));840 }841 continue;842 }843844 if p.at(T![.]) {845 p.eat(T![.])?;846 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;847 parts.push(IndexPart {848 span: id_spanned.span,849 value: id_spanned.value,850 #[cfg(feature = "exp-null-coaelse")]851 null_coaelse: false,852 });853 } else if p.at(T!['[']) {854 p.eat(T!['['])?;855856 if p.at(T![:]) {857 858 flush_index_parts(&mut e, &mut parts);859 let slice = slice_desc(p, None)?;860 p.eat(T![']'])?;861 e = Expr::Slice(Box::new(Slice { value: e, slice }));862 } else {863 let idx = spanned(p, expr)?;864 if p.at(T![:]) {865 866 flush_index_parts(&mut e, &mut parts);867 let slice = slice_desc(p, Some(idx))?;868 p.eat(T![']'])?;869 e = Expr::Slice(Box::new(Slice { value: e, slice }));870 } else {871 872 p.eat(T![']'])?;873 parts.push(IndexPart {874 span: idx.span,875 value: idx.value,876 #[cfg(feature = "exp-null-coaelse")]877 null_coaelse: false,878 });879 }880 }881 } else if p.at(T!['(']) {882 flush_index_parts(&mut e, &mut parts);883 let args_spanned = spanned(p, |p| {884 p.eat(T!['('])?;885 let a = args(p)?;886 p.eat(T![')'])?;887 Ok(a)888 })?;889 let tailstrict = p.try_eat(T![tailstrict]);890 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);891 } else if p.at(T!['{']) {892 flush_index_parts(&mut e, &mut parts);893 p.eat(T!['{'])?;894 let body = objinside(p)?;895 p.eat(T!['}'])?;896 e = Expr::ObjExtend(Box::new(e), body);897 } else {898 break;899 }900 }901902 flush_index_parts(&mut e, &mut parts);903 Ok(e)904}905906fn prefix_binding_power(op: UnaryOpType) -> u8 {907 match op {908 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,909 }910}911912fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {913 match op {914 BinaryOpType::Or => (2, 3),915 #[cfg(feature = "exp-null-coaelse")]916 BinaryOpType::NullCoaelse => (2, 3),917 BinaryOpType::And => (4, 5),918 BinaryOpType::BitOr => (6, 7),919 BinaryOpType::BitXor => (8, 9),920 BinaryOpType::BitAnd => (10, 11),921 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),922 BinaryOpType::Lt923 | BinaryOpType::Gt924 | BinaryOpType::Lte925 | BinaryOpType::Gte926 | BinaryOpType::In => (14, 15),927 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),928 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),929 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),930 }931}932933fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {934 match kind {935 T![+] => Some(UnaryOpType::Plus),936 T![-] => Some(UnaryOpType::Minus),937 T![!] => Some(UnaryOpType::Not),938 T![~] => Some(UnaryOpType::BitNot),939 _ => None,940 }941}942943fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {944 match p.peek() {945 T![||] => Some(BinaryOpType::Or),946 T![&&] => Some(BinaryOpType::And),947 T![|] => Some(BinaryOpType::BitOr),948 T![^] => Some(BinaryOpType::BitXor),949 T![&] => Some(BinaryOpType::BitAnd),950 T![==] => Some(BinaryOpType::Eq),951 T![!=] => Some(BinaryOpType::Neq),952 T![<] => Some(BinaryOpType::Lt),953 T![>] => Some(BinaryOpType::Gt),954 T![<=] => Some(BinaryOpType::Lte),955 T![>=] => Some(BinaryOpType::Gte),956 T![<<] => Some(BinaryOpType::Lhs),957 T![>>] => Some(BinaryOpType::Rhs),958 T![+] => Some(BinaryOpType::Add),959 T![-] => Some(BinaryOpType::Sub),960 T![*] => Some(BinaryOpType::Mul),961 T![/] => Some(BinaryOpType::Div),962 T![%] => Some(BinaryOpType::Mod),963 T![in] => Some(BinaryOpType::In),964 #[cfg(feature = "exp-null-coaelse")]965 T![??] => Some(BinaryOpType::NullCoaelse),966 _ => None,967 }968}969970fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {971 let mut lhs = if let Some(op) = unary_op(p.peek()) {972 p.eat_any();973 let rbp = prefix_binding_power(op);974 let rhs = expr_bp(p, rbp)?;975 Expr::UnaryOp(op, Box::new(rhs))976 } else {977 expr_suffix(p)?978 };979980 loop {981 if p.at_eof() {982 break;983 }984985 let Some(op) = binary_op(p) else {986 break;987 };988989 let (lbp, rbp) = infix_binding_power(op);990 if lbp < min_bp {991 break;992 }993994 p.eat_any();995 let rhs = expr_bp(p, rbp)?;996 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));997 }998999 Ok(lhs)1000}10011002fn expr(p: &mut Parser<'_>) -> Result<Expr> {1003 expr_bp(p, 0)1004}10051006pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1007 let mut p = Parser::new(str, settings.source.clone());1008 for lexeme in &p.lexemes {1009 if let Some(desc) = lexeme.kind.error_description() {1010 return Err(ParseError {1011 message: desc.to_owned(),1012 location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1013 });1014 }1015 }1016 let e = expr(&mut p)?;1017 if !p.at_eof() {1018 return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1019 }1020 Ok(e)1021}10221023pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1024 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10251026 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1027}10281029#[cfg(test)]1030mod tests {1031 use std::fs;10321033 use insta::{assert_snapshot, glob};1034 use jrsonnet_ir::{IStr, Source};10351036 use super::*;10371038 fn parse_str(input: &str) -> Expr {1039 let source = Source::new_virtual("<test>".into(), input.into());1040 let settings = ParserSettings { source };1041 parse(input, &settings).unwrap()1042 }10431044 #[test]1045 #[cfg(not(feature = "exp-null-coaelse"))]1046 fn basic_test() {1047 let v = parse_str("assert true[false] : false ; true");1048 assert_snapshot!(format!("{v:#?}"));1049 }10501051 #[test]1052 fn literals() {1053 let v = parse_str("[null, true, false, self, super, $]");1054 assert_snapshot!(format!("{v:#?}"));1055 }10561057 #[test]1058 fn basic_math() {1059 let v = parse_str("2+2*2");1060 assert_snapshot!(format!("{v:#?}"));1061 }10621063 #[test]1064 fn underscore_numbers() {1065 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1066 assert_snapshot!(format!("{v:#?}"));1067 }10681069 #[test]1070 fn strings() {1071 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1072 assert_snapshot!(format!("{v:#?}"));1073 }10741075 #[test]1076 fn object() {1077 let v = parse_str("{a: 1, b:: 2, c::: 3}");1078 assert_snapshot!(format!("{v:#?}"));1079 }10801081 #[test]1082 fn function_and_call() {1083 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1084 assert_snapshot!(format!("{v:#?}"));1085 }10861087 #[test]1088 fn if_then_else() {1089 let v = parse_str("if true then 1 else 2");1090 assert_snapshot!(format!("{v:#?}"));1091 }10921093 #[test]1094 fn imports() {1095 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1096 assert_snapshot!(format!("{v:#?}"));1097 }10981099 #[test]1100 fn array_comp() {1101 let v = parse_str("[x for x in arr]");1102 assert_snapshot!(format!("{v:#?}"));1103 }11041105 #[test]1106 #[cfg(not(feature = "exp-null-coaelse"))]1107 fn index_and_suffix() {1108 let v = parse_str("std.test(2).field[0]");1109 assert_snapshot!(format!("{v:#?}"));1110 }11111112 #[test]1113 fn obj_extend() {1114 let v = parse_str("{} { x: 1 }");1115 assert_snapshot!(format!("{v:#?}"));1116 }11171118 #[test]1119 fn unary_ops() {1120 let v = parse_str("!a && !b");1121 assert_snapshot!(format!("{v:#?}"));1122 }11231124 #[test]1125 fn error_expr() {1126 let v = parse_str("error \"bad\"");1127 assert_snapshot!(format!("{v:#?}"));1128 }11291130 #[test]1131 fn slice() {1132 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1133 assert_snapshot!(format!("{v:#?}"));1134 }11351136 #[test]1137 #[cfg(not(feature = "exp-null-coaelse"))]1138 fn peg_snapshots() {1139 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1140 let input = fs::read_to_string(path).expect("read test file");1141 let source = Source::new_virtual("<test>".into(), IStr::empty());1142 let settings = ParserSettings { source };1143 let v = parse(&input, &settings).unwrap();1144 let v = format!("{v:#?}");1145 assert_snapshot!(v);1146 });1147 }1148}