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!(224 "expected identifier, got {}",225 p.current_desc()226 )));227 }228 let text = p.text();229 p.eat_any();230 Ok(IStr::from(text))231}232233fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {234 let t = match p.peek() {235 T![self] => LiteralType::This,236 T![super] => LiteralType::Super,237 T!['$'] => LiteralType::Dollar,238 T![null] => LiteralType::Null,239 T![true] => LiteralType::True,240 T![false] => LiteralType::False,241 _ => return None,242 };243 p.eat_any();244 Some(t)245}246247fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {248 p.eat(T![assert])?;249 let assertion = spanned(p, expr)?;250 let message = if p.try_eat(T![:]) {251 Some(expr(p)?)252 } else {253 None254 };255 Ok(AssertStmt { assertion, message })256}257258fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {259 let v = spanned(p, |p| p.eat(T![if]))?;260 let cond = expr(p)?;261 Ok(IfSpecData { span: v.span, cond })262}263264fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {265 let cond = if_spec_data(p)?;266 p.eat(T![then])?;267 let cond_then = expr(p)?;268 let cond_else = if p.try_eat(T![else]) {269 Some(expr(p)?)270 } else {271 None272 };273 Ok(IfElse {274 cond,275 cond_then,276 cond_else,277 })278}279280fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {281 p.eat(T![:])?;282 let end = if !p.at(T![:]) && !p.at(T![']']) {283 Some(spanned(p, expr)?)284 } else {285 None286 };287 let step = if p.try_eat(T![:]) {288 if p.at(T![']']) {289 None290 } else {291 Some(spanned(p, expr)?)292 }293 } else {294 None295 };296 Ok(SliceDesc { start, end, step })297}298299fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {300 if p.at(SyntaxKind::IDENT) {301 return Ok(Destruct::Full(spanned(p, ident)?));302 }303 #[cfg(not(feature = "exp-destruct"))]304 return Err(p.error(format!("expected identifier, got {}", p.current_desc())));305 #[cfg(feature = "exp-destruct")]306 {307 if p.try_eat(T![?]) {308 return Ok(Destruct::Skip);309 }310 if p.at(T!['[']) {311 return destruct_array(p);312 }313 if p.at(T!['{']) {314 return destruct_object(p);315 }316 Err(p.error(format!(317 "expected destructure pattern, got {}",318 p.current_desc()319 )))320 }321}322323#[cfg(feature = "exp-destruct")]324fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {325 p.eat(T![...])?;326 if p.at(SyntaxKind::IDENT) {327 Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))328 } else {329 Ok(jrsonnet_ir::DestructRest::Drop)330 }331}332333#[cfg(feature = "exp-destruct")]334fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {335 p.eat(T!['['])?;336 let mut start = Vec::new();337 let mut rest = None;338 let mut end = Vec::new();339 if !p.at(T![']']) {340 loop {341 if p.at(T![...]) {342 rest = Some(destruct_rest(p)?);343 if p.try_eat(T![,]) {344 if !p.at(T![']']) {345 loop {346 end.push(destruct(p)?);347 if !p.try_eat(T![,]) {348 break;349 }350 if p.at(T![']']) {351 break;352 }353 }354 }355 }356 break;357 }358 start.push(destruct(p)?);359 if !p.try_eat(T![,]) {360 break;361 }362 if p.at(T![']']) {363 break;364 }365 }366 }367 p.eat(T![']'])?;368 Ok(Destruct::Array { start, rest, end })369}370371#[cfg(feature = "exp-destruct")]372fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {373 p.eat(T!['{'])?;374 let mut fields = Vec::new();375 let mut rest = None;376 if !p.at(T!['}']) {377 loop {378 if p.at(T![...]) {379 rest = Some(destruct_rest(p)?);380 p.try_eat(T![,]);381 break;382 }383 let name = ident(p)?;384 let into = if p.try_eat(T![:]) {385 Some(destruct(p)?)386 } else {387 None388 };389 let default = if p.try_eat(T![=]) {390 Some(spanned(p, expr)?)391 } else {392 None393 };394 fields.push((name, into, default));395 if !p.try_eat(T![,]) {396 break;397 }398 if p.at(T!['}']) {399 break;400 }401 }402 }403 p.eat(T!['}'])?;404 Ok(Destruct::Object { fields, rest })405}406407fn params(p: &mut Parser<'_>) -> Result<ExprParams> {408 if p.at(T![')']) {409 return Ok(ExprParams::new(Vec::new()));410 }411 let mut result = Vec::new();412 loop {413 let d = destruct(p)?;414 let default = if p.try_eat(T![=]) {415 Some(expr(p)?)416 } else {417 None418 };419 result.push(ExprParam {420 destruct: d,421 default,422 });423 if !p.try_eat(T![,]) {424 break;425 }426 if p.at(T![')']) {427 break;428 }429 }430 Ok(ExprParams::new(result))431}432433fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {434 if p.at(T![')']) {435 return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));436 }437 let mut unnamed = Vec::new();438 let mut names = Vec::new();439 let mut values = Vec::new();440 let mut named_started = false;441 loop {442 let is_named = p.at(SyntaxKind::IDENT) && {443 let next_offset = p.offset + 1;444 next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]445 };446 if is_named {447 let name: IStr = ident(p)?;448 p.eat(T![=])?;449450 names.push(name);451 values.push(expr(p)?);452 named_started = true;453 } else {454 if named_started {455 return Err(p.error("positional argument after named argument".into()));456 }457 unnamed.push(expr(p)?);458 }459 if !p.try_eat(T![,]) {460 break;461 }462 if p.at(T![')']) {463 break;464 }465 }466 Ok(ArgsDesc::new(unnamed, names, values))467}468469fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {470 #[cfg(feature = "exp-destruct")]471 {472 if !p.at(SyntaxKind::IDENT) {473 let d = destruct(p)?;474 p.eat(T![=])?;475 return Ok(BindSpec::Field {476 into: d,477 value: expr(p)?,478 });479 }480 }481 let name_spanned = spanned(p, ident)?;482 if p.try_eat(T!['(']) {483 let ps = params(p)?;484 p.eat(T![')'])?;485 p.eat(T![=])?;486 Ok(BindSpec::Function {487 name: name_spanned.value,488 params: ps,489 value: expr(p)?,490 })491 } else {492 p.eat(T![=])?;493 Ok(BindSpec::Field {494 into: Destruct::Full(name_spanned),495 value: expr(p)?,496 })497 }498}499500fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {501 p.eat(T![:])?;502 if p.try_eat(T![:]) {503 if p.try_eat(T![:]) {504 Ok(Visibility::Unhide)505 } else {506 Ok(Visibility::Hidden)507 }508 } else {509 Ok(Visibility::Normal)510 }511}512513fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {514 if p.at(SyntaxKind::IDENT) {515 Ok(FieldName::Fixed(ident(p)?))516 } else if is_string_token(p.peek()) {517 Ok(FieldName::Fixed(parse_string_content(p)?))518 } else if p.at(T!['[']) {519 p.eat(T!['['])?;520 let e = expr(p)?;521 p.eat(T![']'])?;522 Ok(FieldName::Dyn(e))523 } else {524 Err(p.error(format!("expected field name, got {}", p.current_desc())))525 }526}527528fn field(p: &mut Parser<'_>) -> Result<FieldMember> {529 let name = spanned(p, field_name)?;530531 if p.at(T!['(']) {532 p.eat(T!['('])?;533 let ps = params(p)?;534 p.eat(T![')'])?;535 let vis = visibility(p)?;536 Ok(FieldMember {537 name,538 plus: false,539 params: Some(ps),540 visibility: vis,541 value: expr(p)?,542 })543 } else {544 let plus = p.try_eat(T![+]);545 let vis = visibility(p)?;546 Ok(FieldMember {547 name,548 plus,549 params: None,550 visibility: vis,551 value: expr(p)?,552 })553 }554}555556fn member(p: &mut Parser<'_>) -> Result<Member> {557 if p.at(T![local]) {558 p.eat(T![local])?;559 Ok(Member::BindStmt(bind(p)?))560 } else if p.at(T![assert]) {561 Ok(Member::AssertStmt(assert_stmt(p)?))562 } else {563 Ok(Member::Field(field(p)?))564 }565}566567fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {568 p.eat(T![for])?;569 let d = destruct(p)?;570 p.eat(T![in])?;571 let over = expr(p)?;572 Ok(ForSpecData { destruct: d, over })573}574575fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {576 let mut specs = Vec::new();577 specs.push(CompSpec::ForSpec(for_spec(p)?));578 loop {579 if p.at(T![for]) {580 specs.push(CompSpec::ForSpec(for_spec(p)?));581 } else if p.at(T![if]) {582 let isd = if_spec_data(p)?;583 specs.push(CompSpec::IfSpec(isd));584 } else {585 break;586 }587 }588 Ok(specs)589}590591fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {592 if p.at(T!['}']) {593 return Ok(ObjBody::MemberList(ObjMembers {594 locals: Vec::new(),595 asserts: Vec::new(),596 fields: Vec::new(),597 }));598 }599600 let mut members = Vec::new();601 loop {602 members.push(member(p)?);603 if !p.try_eat(T![,]) {604 break;605 }606 if p.at(T!['}']) || p.at(T![for]) {607 break;608 }609 }610611 if p.at(T![for]) {612 let specs = compspecs(p)?;613 let mut locals = Vec::new();614 let mut field_member = None;615 for m in members {616 match m {617 Member::Field(f) => {618 if field_member.is_some() {619 return Err(620 p.error("object comprehension can only contain one field".into())621 );622 }623 field_member = Some(f);624 }625 Member::BindStmt(b) => locals.push(b),626 Member::AssertStmt(_) => {627 return Err(p.error("asserts are unsupported in object comprehension".into()));628 }629 }630 }631 Ok(ObjBody::ObjComp(ObjComp {632 locals,633 field: Box::new(634 field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,635 ),636 compspecs: specs,637 }))638 } else {639 let mut locals = Vec::new();640 let mut asserts = Vec::new();641 let mut fields = Vec::new();642 for m in members {643 match m {644 Member::Field(f) => fields.push(f),645 Member::BindStmt(b) => locals.push(b),646 Member::AssertStmt(a) => asserts.push(a),647 }648 }649 Ok(ObjBody::MemberList(ObjMembers {650 locals,651 asserts,652 fields,653 }))654 }655}656657#[allow(clippy::too_many_lines)]658fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {659 if let Some(lit) = literal(p) {660 return Ok(Expr::Literal(lit));661 }662663 match p.peek() {664 SyntaxKind::STRING_DOUBLE665 | SyntaxKind::STRING_SINGLE666 | SyntaxKind::STRING_DOUBLE_VERBATIM667 | SyntaxKind::STRING_SINGLE_VERBATIM668 | SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),669670 SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),671672 T!['('] => {673 p.eat(T!['('])?;674 let e = expr(p)?;675 p.eat(T![')'])?;676 Ok(e)677 }678679 T!['['] => {680 p.eat(T!['['])?;681 if p.at(T![']']) {682 p.eat(T![']'])?;683 return Ok(Expr::Arr(Vec::new()));684 }685 let first = expr(p)?;686 if p.at(T![for]) {687 let specs = compspecs(p)?;688 p.eat(T![']'])?;689 Ok(Expr::ArrComp(Box::new(first), specs))690 } else if p.at(T![,]) && {691 let next = p.offset + 1;692 next < p.lexemes.len() && p.lexemes[next].kind == T![for]693 } {694 p.eat(T![,])?;695 let specs = compspecs(p)?;696 p.eat(T![']'])?;697 Ok(Expr::ArrComp(Box::new(first), specs))698 } else {699 let mut elems = vec![first];700 while p.try_eat(T![,]) {701 if p.at(T![']']) {702 break;703 }704 elems.push(expr(p)?);705 }706 p.eat(T![']'])?;707 Ok(Expr::Arr(elems))708 }709 }710711 T!['{'] => {712 p.eat(T!['{'])?;713 let body = objinside(p)?;714 p.eat(T!['}'])?;715 Ok(Expr::Obj(body))716 }717718 T![local] => {719 p.eat(T![local])?;720 let mut binds = Vec::new();721 loop {722 if p.at(T![;]) {723 break;724 }725 binds.push(bind(p)?);726 if !p.try_eat(T![,]) {727 break;728 }729 }730 p.eat(T![;])?;731 let body = expr(p)?;732 Ok(Expr::LocalExpr(binds, Box::new(body)))733 }734735 T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),736737 T![function] => {738 p.eat(T![function])?;739 p.eat(T!['('])?;740 let ps = params(p)?;741 p.eat(T![')'])?;742 let body = expr(p)?;743 Ok(Expr::Function(ps, Box::new(body)))744 }745746 T![assert] => {747 let a = assert_stmt(p)?;748 p.eat(T![;])?;749 let rest = expr(p)?;750 Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))751 }752753 T![error] => {754 let span = spanned(p, |p| p.eat(T![error]))?;755 let e = expr(p)?;756 Ok(Expr::ErrorStmt(span.span, Box::new(e)))757 }758759 T![importstr] => {760 let kind = spanned(p, |p| {761 p.eat(T![importstr])?;762 Ok(ImportKind::Str)763 })?;764 let path = expr(p)?;765 Ok(Expr::Import(kind, Box::new(path)))766 }767768 T![importbin] => {769 let kind = spanned(p, |p| {770 p.eat(T![importbin])?;771 Ok(ImportKind::Bin)772 })?;773 let path = expr(p)?;774 Ok(Expr::Import(kind, Box::new(path)))775 }776777 T![import] => {778 let kind = spanned(p, |p| {779 p.eat(T![import])?;780 Ok(ImportKind::Normal)781 })?;782 let path = expr(p)?;783 Ok(Expr::Import(kind, Box::new(path)))784 }785786 SyntaxKind::IDENT => {787 let n = spanned(p, |p| {788 let s: IStr = p.text().into();789 p.eat_any();790 Ok(s)791 })?;792 Ok(Expr::Var(n))793 }794795 _ => Err(p.error(format!("unexpected {}", p.current_desc()))),796 }797}798799fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {800 if parts.is_empty() {801 return;802 }803 let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));804 *e = Expr::Index {805 indexable: Box::new(old),806 parts: std::mem::take(parts),807 };808}809810fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {811 let mut e = expr_basic(p)?;812 813 814 815 let mut parts: Vec<IndexPart> = Vec::new();816817 loop {818 #[cfg(feature = "exp-null-coaelse")]819 if p.at(T![?]) {820 p.eat_any();821 if p.try_eat(T![.]) {822 if p.at(T!['[']) {823 824 p.eat(T!['['])?;825 let idx = spanned(p, expr)?;826 p.eat(T![']'])?;827 parts.push(IndexPart {828 span: idx.span,829 value: idx.value,830 null_coaelse: true,831 });832 } else {833 834 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;835 parts.push(IndexPart {836 span: id_spanned.span,837 value: id_spanned.value,838 null_coaelse: true,839 });840 }841 } else {842 return Err(p.error("expected '.' after '?'".into()));843 }844 continue;845 }846847 if p.at(T![.]) {848 p.eat(T![.])?;849 let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;850 parts.push(IndexPart {851 span: id_spanned.span,852 value: id_spanned.value,853 #[cfg(feature = "exp-null-coaelse")]854 null_coaelse: false,855 });856 } else if p.at(T!['[']) {857 p.eat(T!['['])?;858859 if p.at(T![:]) {860 861 flush_index_parts(&mut e, &mut parts);862 let slice = slice_desc(p, None)?;863 p.eat(T![']'])?;864 e = Expr::Slice(Box::new(Slice { value: e, slice }));865 } else {866 let idx = spanned(p, expr)?;867 if p.at(T![:]) {868 869 flush_index_parts(&mut e, &mut parts);870 let slice = slice_desc(p, Some(idx))?;871 p.eat(T![']'])?;872 e = Expr::Slice(Box::new(Slice { value: e, slice }));873 } else {874 875 p.eat(T![']'])?;876 parts.push(IndexPart {877 span: idx.span,878 value: idx.value,879 #[cfg(feature = "exp-null-coaelse")]880 null_coaelse: false,881 });882 }883 }884 } else if p.at(T!['(']) {885 flush_index_parts(&mut e, &mut parts);886 let args_spanned = spanned(p, |p| {887 p.eat(T!['('])?;888 let a = args(p)?;889 p.eat(T![')'])?;890 Ok(a)891 })?;892 let tailstrict = p.try_eat(T![tailstrict]);893 e = Expr::Apply(Box::new(e), args_spanned, tailstrict);894 } else if p.at(T!['{']) {895 flush_index_parts(&mut e, &mut parts);896 p.eat(T!['{'])?;897 let body = objinside(p)?;898 p.eat(T!['}'])?;899 e = Expr::ObjExtend(Box::new(e), body);900 } else {901 break;902 }903 }904905 flush_index_parts(&mut e, &mut parts);906 Ok(e)907}908909fn prefix_binding_power(op: UnaryOpType) -> u8 {910 match op {911 UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,912 }913}914915fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {916 match op {917 BinaryOpType::Or => (2, 3),918 #[cfg(feature = "exp-null-coaelse")]919 BinaryOpType::NullCoaelse => (2, 3),920 BinaryOpType::And => (4, 5),921 BinaryOpType::BitOr => (6, 7),922 BinaryOpType::BitXor => (8, 9),923 BinaryOpType::BitAnd => (10, 11),924 BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),925 BinaryOpType::Lt926 | BinaryOpType::Gt927 | BinaryOpType::Lte928 | BinaryOpType::Gte929 | BinaryOpType::In => (14, 15),930 BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),931 BinaryOpType::Add | BinaryOpType::Sub => (18, 19),932 BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),933 }934}935936fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {937 match kind {938 T![+] => Some(UnaryOpType::Plus),939 T![-] => Some(UnaryOpType::Minus),940 T![!] => Some(UnaryOpType::Not),941 T![~] => Some(UnaryOpType::BitNot),942 _ => None,943 }944}945946fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {947 match p.peek() {948 T![||] => Some(BinaryOpType::Or),949 T![&&] => Some(BinaryOpType::And),950 T![|] => Some(BinaryOpType::BitOr),951 T![^] => Some(BinaryOpType::BitXor),952 T![&] => Some(BinaryOpType::BitAnd),953 T![==] => Some(BinaryOpType::Eq),954 T![!=] => Some(BinaryOpType::Neq),955 T![<] => Some(BinaryOpType::Lt),956 T![>] => Some(BinaryOpType::Gt),957 T![<=] => Some(BinaryOpType::Lte),958 T![>=] => Some(BinaryOpType::Gte),959 T![<<] => Some(BinaryOpType::Lhs),960 T![>>] => Some(BinaryOpType::Rhs),961 T![+] => Some(BinaryOpType::Add),962 T![-] => Some(BinaryOpType::Sub),963 T![*] => Some(BinaryOpType::Mul),964 T![/] => Some(BinaryOpType::Div),965 T![%] => Some(BinaryOpType::Mod),966 T![in] => Some(BinaryOpType::In),967 #[cfg(feature = "exp-null-coaelse")]968 T![??] => Some(BinaryOpType::NullCoaelse),969 _ => None,970 }971}972973fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {974 let mut lhs = if let Some(op) = unary_op(p.peek()) {975 p.eat_any();976 let rbp = prefix_binding_power(op);977 let rhs = expr_bp(p, rbp)?;978 Expr::UnaryOp(op, Box::new(rhs))979 } else {980 expr_suffix(p)?981 };982983 loop {984 if p.at_eof() {985 break;986 }987988 let Some(op) = binary_op(p) else {989 break;990 };991992 let (lbp, rbp) = infix_binding_power(op);993 if lbp < min_bp {994 break;995 }996997 p.eat_any();998 let rhs = expr_bp(p, rbp)?;999 lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1000 }10011002 Ok(lhs)1003}10041005fn expr(p: &mut Parser<'_>) -> Result<Expr> {1006 expr_bp(p, 0)1007}10081009pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1010 let mut p = Parser::new(str, settings.source.clone());1011 for lexeme in &p.lexemes {1012 if let Some(desc) = lexeme.kind.error_description() {1013 return Err(ParseError {1014 message: desc.to_owned(),1015 location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1016 });1017 }1018 }1019 let e = expr(&mut p)?;1020 if !p.at_eof() {1021 return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1022 }1023 Ok(e)1024}10251026pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1027 let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10281029 Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1030}10311032#[cfg(test)]1033mod tests {1034 use std::fs;10351036 use insta::{assert_snapshot, glob};1037 use jrsonnet_ir::{IStr, Source};10381039 use super::*;10401041 fn parse_str(input: &str) -> Expr {1042 let source = Source::new_virtual("<test>".into(), input.into());1043 let settings = ParserSettings { source };1044 parse(input, &settings).unwrap()1045 }10461047 #[test]1048 #[cfg(not(feature = "exp-null-coaelse"))]1049 fn basic_test() {1050 let v = parse_str("assert true[false] : false ; true");1051 assert_snapshot!(format!("{v:#?}"));1052 }10531054 #[test]1055 fn literals() {1056 let v = parse_str("[null, true, false, self, super, $]");1057 assert_snapshot!(format!("{v:#?}"));1058 }10591060 #[test]1061 fn basic_math() {1062 let v = parse_str("2+2*2");1063 assert_snapshot!(format!("{v:#?}"));1064 }10651066 #[test]1067 fn underscore_numbers() {1068 let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1069 assert_snapshot!(format!("{v:#?}"));1070 }10711072 #[test]1073 fn strings() {1074 let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1075 assert_snapshot!(format!("{v:#?}"));1076 }10771078 #[test]1079 fn object() {1080 let v = parse_str("{a: 1, b:: 2, c::: 3}");1081 assert_snapshot!(format!("{v:#?}"));1082 }10831084 #[test]1085 fn function_and_call() {1086 let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1087 assert_snapshot!(format!("{v:#?}"));1088 }10891090 #[test]1091 fn if_then_else() {1092 let v = parse_str("if true then 1 else 2");1093 assert_snapshot!(format!("{v:#?}"));1094 }10951096 #[test]1097 fn imports() {1098 let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1099 assert_snapshot!(format!("{v:#?}"));1100 }11011102 #[test]1103 fn array_comp() {1104 let v = parse_str("[x for x in arr]");1105 assert_snapshot!(format!("{v:#?}"));1106 }11071108 #[test]1109 #[cfg(not(feature = "exp-null-coaelse"))]1110 fn index_and_suffix() {1111 let v = parse_str("std.test(2).field[0]");1112 assert_snapshot!(format!("{v:#?}"));1113 }11141115 #[test]1116 fn obj_extend() {1117 let v = parse_str("{} { x: 1 }");1118 assert_snapshot!(format!("{v:#?}"));1119 }11201121 #[test]1122 fn unary_ops() {1123 let v = parse_str("!a && !b");1124 assert_snapshot!(format!("{v:#?}"));1125 }11261127 #[test]1128 fn error_expr() {1129 let v = parse_str("error \"bad\"");1130 assert_snapshot!(format!("{v:#?}"));1131 }11321133 #[test]1134 fn slice() {1135 let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1136 assert_snapshot!(format!("{v:#?}"));1137 }11381139 #[test]1140 #[cfg(not(feature = "exp-null-coaelse"))]1141 fn peg_snapshots() {1142 glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1143 let input = fs::read_to_string(path).expect("read test file");1144 let source = Source::new_virtual("<test>".into(), IStr::empty());1145 let settings = ParserSettings { source };1146 let v = parse(&input, &settings).unwrap();1147 let v = format!("{v:#?}");1148 assert_snapshot!(v);1149 });1150 }1151}