git.delta.rocks / jrsonnet / refs/commits / e9c741d736e9

1use std::rc::Rc;23use jrsonnet_gcmodule::Acyclic;4use jrsonnet_ir::{5	ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,6	ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,7	ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice, SliceDesc,8	Source, Span, Spanned, UnaryOpType, Visibility, unescape,9};10use jrsonnet_lexer::{Lexeme, Lexer, Span as LexSpan, SyntaxKind, T, collect_lexed_str_block};1112pub struct ParserSettings {13	pub source: Source,14}1516#[derive(Debug, Clone)]17pub struct ParseError {18	pub message: String,19	pub location: LexSpan,20}2122impl std::fmt::Display for ParseError {23	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {24		write!(f, "{}", self.message)25	}26}2728type Result<T> = std::result::Result<T, ParseError>;2930struct Parser<'a> {31	lexemes: Vec<Lexeme<'a>>,32	offset: usize,33	source: Source,34}3536impl<'a> Parser<'a> {37	fn new(code: &'a str, source: Source) -> Self {38		Self {39			lexemes: Lexer::new(code)40				.filter(|l| {41					!matches!(42						l.kind,43						SyntaxKind::WHITESPACE44							| SyntaxKind::SINGLE_LINE_SLASH_COMMENT45							| SyntaxKind::SINGLE_LINE_HASH_COMMENT46							| SyntaxKind::MULTI_LINE_COMMENT47					)48				})49				.collect(),50			offset: 0,51			source,52		}53	}5455	fn peek(&self) -> SyntaxKind {56		if self.at_eof() {57			SyntaxKind::EOF58		} else {59			self.lexemes[self.offset].kind60		}61	}6263	fn text(&self) -> &'a str {64		self.lexemes[self.offset].text65	}6667	fn at(&self, kind: SyntaxKind) -> bool {68		!self.at_eof() && self.peek() == kind69	}7071	fn eat_any(&mut self) {72		self.offset += 1;73	}7475	fn at_eof(&self) -> bool {76		self.offset >= self.lexemes.len()77	}7879	fn try_eat(&mut self, t: SyntaxKind) -> bool {80		if self.at(t) {81			self.eat_any();82			return true;83		}84		false85	}8687	fn current_desc(&self) -> String {88		if self.at_eof() {89			return "end of file".to_owned();90		}91		let kind = self.peek();92		let text = self.text();93		let name = kind.display_name();94		if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {95			format!("{name} \"{text}\"")96		} else {97			name.to_owned()98		}99	}100101	fn eat(&mut self, t: SyntaxKind) -> Result<()> {102		if !self.at(t) {103			return Err(self.error(format!(104				"expected {}, got {}",105				t.display_name(),106				self.current_desc(),107			)));108		}109		self.eat_any();110		Ok(())111	}112113	fn span_start(&self) -> u32 {114		if self.at_eof() {115			if let Some(last) = self.lexemes.last() {116				return last.range.1;117			}118			return 0;119		}120		self.lexemes[self.offset].range.0121	}122123	fn span_end(&self) -> u32 {124		self.lexemes[self.offset - 1].range.1125	}126127	fn error(&self, message: String) -> ParseError {128		if self.offset == self.lexemes.len() {129			let pos = self.lexemes.last().map_or(0, |v| v.range.1);130			return ParseError {131				location: LexSpan(pos, pos),132				message,133			};134		}135		ParseError {136			location: self.lexemes[self.offset].range,137			message,138		}139	}140}141142fn spanned<T: Acyclic>(143	p: &mut Parser<'_>,144	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,145) -> Result<Spanned<T>> {146	let start = p.span_start();147	let v = cb(p)?;148	let end = p.span_end();149	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))150}151152fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {153	let kind = p.peek();154	let text = p.text();155	let s = match kind {156		SyntaxKind::STRING_DOUBLE => {157			let inner = &text[1..text.len() - 1];158			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?159		}160		SyntaxKind::STRING_SINGLE => {161			let inner = &text[1..text.len() - 1];162			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?163		}164		SyntaxKind::STRING_DOUBLE_VERBATIM => {165			let inner = &text[2..text.len() - 1];166			inner.replace("\"\"", "\"")167		}168		SyntaxKind::STRING_SINGLE_VERBATIM => {169			let inner = &text[2..text.len() - 1];170			inner.replace("''", "'")171		}172		SyntaxKind::STRING_BLOCK => {173			let inner = &text[3..];174			let collected = collect_lexed_str_block(inner)175				.map_err(|_| p.error("invalid string block".into()))?;176			let mut result = String::new();177			for (i, line) in collected.lines.iter().enumerate() {178				if i > 0 {179					result.push('\n');180				}181				result.push_str(line);182			}183			if !collected.truncate {184				result.push('\n');185			}186			result187		}188		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),189	};190	p.eat_any();191	Ok(s.into())192}193194fn is_string_token(kind: SyntaxKind) -> bool {195	matches!(196		kind,197		SyntaxKind::STRING_DOUBLE198			| SyntaxKind::STRING_SINGLE199			| SyntaxKind::STRING_DOUBLE_VERBATIM200			| SyntaxKind::STRING_SINGLE_VERBATIM201			| SyntaxKind::STRING_BLOCK202	)203}204205fn parse_number(p: &mut Parser<'_>) -> Result<f64> {206	let text = p.text();207	let n: f64 = text208		.replace('_', "")209		.parse()210		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;211	if !n.is_finite() {212		return Err(p.error("numbers are finite".into()));213	}214	p.eat_any();215	Ok(n)216}217218fn ident(p: &mut Parser<'_>) -> Result<IStr> {219	let text = p.text();220	p.eat(SyntaxKind::IDENT)?;221	Ok(IStr::from(text))222}223224fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {225	let t = match p.peek() {226		T![self] => LiteralType::This,227		T![super] => LiteralType::Super,228		T!['$'] => LiteralType::Dollar,229		T![null] => LiteralType::Null,230		T![true] => LiteralType::True,231		T![false] => LiteralType::False,232		_ => return None,233	};234	p.eat_any();235	Some(t)236}237238fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {239	p.eat(T![assert])?;240	let cond = spanned(p, expr)?;241	let msg = if p.try_eat(T![:]) {242		Some(spanned(p, expr)?)243	} else {244		None245	};246	Ok(AssertStmt(cond, msg))247}248249fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {250	let v = spanned(p, |p| p.eat(T![if]))?;251	let cond = expr(p)?;252	Ok(IfSpecData { span: v.span, cond })253}254255fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {256	let cond = if_spec_data(p)?;257	p.eat(T![then])?;258	let cond_then = expr(p)?;259	let cond_else = if p.try_eat(T![else]) {260		Some(expr(p)?)261	} else {262		None263	};264	Ok(IfElse {265		cond,266		cond_then,267		cond_else,268	})269}270271fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {272	p.eat(T![:])?;273	let end = if !p.at(T![:]) && !p.at(T![']']) {274		Some(spanned(p, expr)?)275	} else {276		None277	};278	let step = if p.try_eat(T![:]) {279		if p.at(T![']']) {280			None281		} else {282			Some(spanned(p, expr)?)283		}284	} else {285		None286	};287	Ok(SliceDesc { start, end, step })288}289290fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {291	if p.at(SyntaxKind::IDENT) {292		return Ok(Destruct::Full(ident(p)?));293	}294	#[cfg(not(feature = "exp-destruct"))]295	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));296	#[cfg(feature = "exp-destruct")]297	{298		if p.try_eat(T![?]) {299			return Ok(Destruct::Skip);300		}301		if p.at(T!['[']) {302			return destruct_array(p);303		}304		if p.at(T!['{']) {305			return destruct_object(p);306		}307		Err(p.error(format!(308			"expected destructure pattern, got {}",309			p.current_desc()310		)))311	}312}313314#[cfg(feature = "exp-destruct")]315fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {316	p.eat(T![...])?;317	if p.at(SyntaxKind::IDENT) {318		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))319	} else {320		Ok(jrsonnet_ir::DestructRest::Drop)321	}322}323324#[cfg(feature = "exp-destruct")]325fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {326	p.eat(T!['['])?;327	let mut start = Vec::new();328	let mut rest = None;329	let mut end = Vec::new();330	if !p.at(T![']']) {331		loop {332			if p.at(T![...]) {333				rest = Some(destruct_rest(p)?);334				if p.try_eat(T![,]) {335					if !p.at(T![']']) {336						loop {337							end.push(destruct(p)?);338							if !p.try_eat(T![,]) {339								break;340							}341							if p.at(T![']']) {342								break;343							}344						}345					}346				}347				break;348			}349			start.push(destruct(p)?);350			if !p.try_eat(T![,]) {351				break;352			}353			if p.at(T![']']) {354				break;355			}356		}357	}358	p.eat(T![']'])?;359	Ok(Destruct::Array { start, rest, end })360}361362#[cfg(feature = "exp-destruct")]363fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {364	p.eat(T!['{'])?;365	let mut fields = Vec::new();366	let mut rest = None;367	if !p.at(T!['}']) {368		loop {369			if p.at(T![...]) {370				rest = Some(destruct_rest(p)?);371				p.try_eat(T![,]);372				break;373			}374			let name = ident(p)?;375			let into = if p.try_eat(T![:]) {376				Some(destruct(p)?)377			} else {378				None379			};380			let default = if p.try_eat(T![=]) {381				Some(Rc::new(spanned(p, expr)?))382			} else {383				None384			};385			fields.push((name, into, default));386			if !p.try_eat(T![,]) {387				break;388			}389			if p.at(T!['}']) {390				break;391			}392		}393	}394	p.eat(T!['}'])?;395	Ok(Destruct::Object { fields, rest })396}397398fn params(p: &mut Parser<'_>) -> Result<ExprParams> {399	if p.at(T![')']) {400		return Ok(ExprParams::new(Vec::new()));401	}402	let mut result = Vec::new();403	loop {404		let d = destruct(p)?;405		let default = if p.try_eat(T![=]) {406			Some(Rc::new(expr(p)?))407		} else {408			None409		};410		result.push(ExprParam {411			destruct: d,412			default,413		});414		if !p.try_eat(T![,]) {415			break;416		}417		if p.at(T![')']) {418			break;419		}420	}421	Ok(ExprParams::new(result))422}423424fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {425	if p.at(T![')']) {426		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));427	}428	let mut unnamed = Vec::new();429	let mut names = Vec::new();430	let mut values = Vec::new();431	let mut named_started = false;432	loop {433		let is_named = p.at(SyntaxKind::IDENT) && {434			let next_offset = p.offset + 1;435			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]436		};437		if is_named {438			let name: IStr = ident(p)?;439			p.eat(T![=])?;440			let value = Rc::new(expr(p)?);441442			names.push(name);443			values.push(value);444			named_started = true;445		} else {446			if named_started {447				return Err(p.error("positional argument after named argument".into()));448			}449			unnamed.push(Rc::new(expr(p)?));450		}451		if !p.try_eat(T![,]) {452			break;453		}454		if p.at(T![')']) {455			break;456		}457	}458	Ok(ArgsDesc::new(unnamed, names, values))459}460461fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {462	#[cfg(feature = "exp-destruct")]463	{464		if !p.at(SyntaxKind::IDENT) {465			let d = destruct(p)?;466			p.eat(T![=])?;467			let value = Rc::new(expr(p)?);468			return Ok(BindSpec::Field { into: d, value });469		}470	}471	let name = ident(p)?;472	if p.try_eat(T!['(']) {473		let ps = params(p)?;474		p.eat(T![')'])?;475		p.eat(T![=])?;476		let value = Rc::new(expr(p)?);477		Ok(BindSpec::Function {478			name,479			params: ps,480			value,481		})482	} else {483		p.eat(T![=])?;484		let value = Rc::new(expr(p)?);485		Ok(BindSpec::Field {486			into: Destruct::Full(name),487			value,488		})489	}490}491492fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {493	p.eat(T![:])?;494	if p.try_eat(T![:]) {495		if p.try_eat(T![:]) {496			Ok(Visibility::Unhide)497		} else {498			Ok(Visibility::Hidden)499		}500	} else {501		Ok(Visibility::Normal)502	}503}504505fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {506	if p.at(SyntaxKind::IDENT) {507		Ok(FieldName::Fixed(ident(p)?))508	} else if is_string_token(p.peek()) {509		Ok(FieldName::Fixed(parse_string_content(p)?))510	} else if p.at(T!['[']) {511		p.eat(T!['['])?;512		let e = expr(p)?;513		p.eat(T![']'])?;514		Ok(FieldName::Dyn(e))515	} else {516		Err(p.error(format!("expected field name, got {}", p.current_desc())))517	}518}519520fn field(p: &mut Parser<'_>) -> Result<FieldMember> {521	let name = spanned(p, field_name)?;522523	if p.at(T!['(']) {524		p.eat(T!['('])?;525		let ps = params(p)?;526		p.eat(T![')'])?;527		let vis = visibility(p)?;528		let value = Rc::new(expr(p)?);529		Ok(FieldMember {530			name,531			plus: false,532			params: Some(ps),533			visibility: vis,534			value,535		})536	} else {537		let plus = p.try_eat(T![+]);538		let vis = visibility(p)?;539		let value = Rc::new(expr(p)?);540		Ok(FieldMember {541			name,542			plus,543			params: None,544			visibility: vis,545			value,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: Rc::new(Vec::new()),589			asserts: Rc::new(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: Rc::new(locals),627			field: Rc::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: Rc::new(locals),645			asserts: Rc::new(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(Rc::new(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(Rc::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(Rc::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(Rc::new(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				binds.push(bind(p)?);717				if !p.try_eat(T![,]) {718					break;719				}720			}721			p.eat(T![;])?;722			let body = expr(p)?;723			Ok(Expr::LocalExpr(binds, Box::new(body)))724		}725726		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),727728		T![function] => {729			p.eat(T![function])?;730			p.eat(T!['('])?;731			let ps = params(p)?;732			p.eat(T![')'])?;733			let body = expr(p)?;734			Ok(Expr::Function(ps, Rc::new(body)))735		}736737		T![assert] => {738			let a = assert_stmt(p)?;739			p.eat(T![;])?;740			let rest = expr(p)?;741			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))742		}743744		T![error] => {745			let span = spanned(p, |p| p.eat(T![error]))?;746			let e = expr(p)?;747			Ok(Expr::ErrorStmt(span.span, Box::new(e)))748		}749750		T![importstr] => {751			let kind = spanned(p, |p| {752				p.eat(T![importstr])?;753				Ok(ImportKind::Str)754			})?;755			let path = expr(p)?;756			Ok(Expr::Import(kind, Box::new(path)))757		}758759		T![importbin] => {760			let kind = spanned(p, |p| {761				p.eat(T![importbin])?;762				Ok(ImportKind::Bin)763			})?;764			let path = expr(p)?;765			Ok(Expr::Import(kind, Box::new(path)))766		}767768		T![import] => {769			let kind = spanned(p, |p| {770				p.eat(T![import])?;771				Ok(ImportKind::Normal)772			})?;773			let path = expr(p)?;774			Ok(Expr::Import(kind, Box::new(path)))775		}776777		SyntaxKind::IDENT => {778			let n = spanned(p, |p| {779				let s: IStr = p.text().into();780				p.eat_any();781				Ok(s)782			})?;783			Ok(Expr::Var(n))784		}785786		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),787	}788}789790fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {791	if parts.is_empty() {792		return;793	}794	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));795	*e = Expr::Index {796		indexable: Box::new(old),797		parts: std::mem::take(parts),798	};799}800801fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {802	let mut e = expr_basic(p)?;803	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])804	// into a single Expr::Index. This is critical for null-coalesce semantics:805	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.806	let mut parts: Vec<IndexPart> = Vec::new();807808	loop {809		#[cfg(feature = "exp-null-coaelse")]810		if p.at(T![?]) {811			p.eat_any();812			if p.try_eat(T![.]) {813				if p.at(T!['[']) {814					// ?.[expr]815					p.eat(T!['['])?;816					let idx = spanned(p, expr)?;817					p.eat(T![']'])?;818					parts.push(IndexPart {819						span: idx.span,820						value: idx.value,821						null_coaelse: true,822					});823				} else {824					// ?.field825					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;826					parts.push(IndexPart {827						span: id_spanned.span,828						value: id_spanned.value,829						null_coaelse: true,830					});831				}832			} else {833				return Err(p.error("expected '.' after '?'".into()));834			}835			continue;836		}837838		if p.at(T![.]) {839			p.eat(T![.])?;840			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;841			parts.push(IndexPart {842				span: id_spanned.span,843				value: id_spanned.value,844				#[cfg(feature = "exp-null-coaelse")]845				null_coaelse: false,846			});847		} else if p.at(T!['[']) {848			p.eat(T!['['])?;849850			if p.at(T![:]) {851				// Slice: flush index parts first, then handle slice852				flush_index_parts(&mut e, &mut parts);853				let slice = slice_desc(p, None)?;854				p.eat(T![']'])?;855				e = Expr::Slice(Box::new(Slice { value: e, slice }));856			} else {857				let idx = spanned(p, expr)?;858				if p.at(T![:]) {859					// Slice with start: flush index parts first860					flush_index_parts(&mut e, &mut parts);861					let slice = slice_desc(p, Some(idx))?;862					p.eat(T![']'])?;863					e = Expr::Slice(Box::new(Slice { value: e, slice }));864				} else {865					// Bracket index: add to parts866					p.eat(T![']'])?;867					parts.push(IndexPart {868						span: idx.span,869						value: idx.value,870						#[cfg(feature = "exp-null-coaelse")]871						null_coaelse: false,872					});873				}874			}875		} else if p.at(T!['(']) {876			flush_index_parts(&mut e, &mut parts);877			let args_spanned = spanned(p, |p| {878				p.eat(T!['('])?;879				let a = args(p)?;880				p.eat(T![')'])?;881				Ok(a)882			})?;883			let tailstrict = p.try_eat(T![tailstrict]);884			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);885		} else if p.at(T!['{']) {886			flush_index_parts(&mut e, &mut parts);887			p.eat(T!['{'])?;888			let body = objinside(p)?;889			p.eat(T!['}'])?;890			e = Expr::ObjExtend(Rc::new(e), body);891		} else {892			break;893		}894	}895896	flush_index_parts(&mut e, &mut parts);897	Ok(e)898}899900fn prefix_binding_power(op: UnaryOpType) -> u8 {901	match op {902		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,903	}904}905906fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {907	match op {908		BinaryOpType::Or => (2, 3),909		#[cfg(feature = "exp-null-coaelse")]910		BinaryOpType::NullCoaelse => (2, 3),911		BinaryOpType::And => (4, 5),912		BinaryOpType::BitOr => (6, 7),913		BinaryOpType::BitXor => (8, 9),914		BinaryOpType::BitAnd => (10, 11),915		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),916		BinaryOpType::Lt917		| BinaryOpType::Gt918		| BinaryOpType::Lte919		| BinaryOpType::Gte920		| BinaryOpType::In => (14, 15),921		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),922		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),923		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),924	}925}926927fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {928	match kind {929		T![+] => Some(UnaryOpType::Plus),930		T![-] => Some(UnaryOpType::Minus),931		T![!] => Some(UnaryOpType::Not),932		T![~] => Some(UnaryOpType::BitNot),933		_ => None,934	}935}936937fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {938	match p.peek() {939		T![||] => Some(BinaryOpType::Or),940		T![&&] => Some(BinaryOpType::And),941		T![|] => Some(BinaryOpType::BitOr),942		T![^] => Some(BinaryOpType::BitXor),943		T![&] => Some(BinaryOpType::BitAnd),944		T![==] => Some(BinaryOpType::Eq),945		T![!=] => Some(BinaryOpType::Neq),946		T![<] => Some(BinaryOpType::Lt),947		T![>] => Some(BinaryOpType::Gt),948		T![<=] => Some(BinaryOpType::Lte),949		T![>=] => Some(BinaryOpType::Gte),950		T![<<] => Some(BinaryOpType::Lhs),951		T![>>] => Some(BinaryOpType::Rhs),952		T![+] => Some(BinaryOpType::Add),953		T![-] => Some(BinaryOpType::Sub),954		T![*] => Some(BinaryOpType::Mul),955		T![/] => Some(BinaryOpType::Div),956		T![%] => Some(BinaryOpType::Mod),957		T![in] => Some(BinaryOpType::In),958		#[cfg(feature = "exp-null-coaelse")]959		T![??] => Some(BinaryOpType::NullCoaelse),960		_ => None,961	}962}963964fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {965	let mut lhs = if let Some(op) = unary_op(p.peek()) {966		p.eat_any();967		let rbp = prefix_binding_power(op);968		let rhs = expr_bp(p, rbp)?;969		Expr::UnaryOp(op, Box::new(rhs))970	} else {971		expr_suffix(p)?972	};973974	loop {975		if p.at_eof() {976			break;977		}978979		let Some(op) = binary_op(p) else {980			break;981		};982983		let (lbp, rbp) = infix_binding_power(op);984		if lbp < min_bp {985			break;986		}987988		p.eat_any();989		let rhs = expr_bp(p, rbp)?;990		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));991	}992993	Ok(lhs)994}995996fn expr(p: &mut Parser<'_>) -> Result<Expr> {997	expr_bp(p, 0)998}9991000pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1001	let mut p = Parser::new(str, settings.source.clone());1002	for lexeme in &p.lexemes {1003		if let Some(desc) = lexeme.kind.error_description() {1004			return Err(ParseError {1005				message: desc.to_owned(),1006				location: lexeme.range,1007			});1008		}1009	}1010	let e = expr(&mut p)?;1011	if !p.at_eof() {1012		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1013	}1014	Ok(e)1015}10161017pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1018	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10191020	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1021}10221023#[cfg(test)]1024mod tests {1025	use std::fs;10261027	use insta::{assert_snapshot, glob};1028	use jrsonnet_ir::{IStr, Source};10291030	use super::*;10311032	fn parse_str(input: &str) -> Expr {1033		let source = Source::new_virtual("<test>".into(), input.into());1034		let settings = ParserSettings { source };1035		parse(input, &settings).unwrap()1036	}10371038	#[test]1039	#[cfg(not(feature = "exp-null-coaelse"))]1040	fn basic_test() {1041		let v = parse_str("assert true[false] : false ; true");1042		assert_snapshot!(format!("{v:#?}"));1043	}10441045	#[test]1046	fn literals() {1047		let v = parse_str("[null, true, false, self, super, $]");1048		assert_snapshot!(format!("{v:#?}"));1049	}10501051	#[test]1052	fn basic_math() {1053		let v = parse_str("2+2*2");1054		assert_snapshot!(format!("{v:#?}"));1055	}10561057	#[test]1058	fn underscore_numbers() {1059		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1060		assert_snapshot!(format!("{v:#?}"));1061	}10621063	#[test]1064	fn strings() {1065		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1066		assert_snapshot!(format!("{v:#?}"));1067	}10681069	#[test]1070	fn object() {1071		let v = parse_str("{a: 1, b:: 2, c::: 3}");1072		assert_snapshot!(format!("{v:#?}"));1073	}10741075	#[test]1076	fn function_and_call() {1077		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1078		assert_snapshot!(format!("{v:#?}"));1079	}10801081	#[test]1082	fn if_then_else() {1083		let v = parse_str("if true then 1 else 2");1084		assert_snapshot!(format!("{v:#?}"));1085	}10861087	#[test]1088	fn imports() {1089		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1090		assert_snapshot!(format!("{v:#?}"));1091	}10921093	#[test]1094	fn array_comp() {1095		let v = parse_str("[x for x in arr]");1096		assert_snapshot!(format!("{v:#?}"));1097	}10981099	#[test]1100	#[cfg(not(feature = "exp-null-coaelse"))]1101	fn index_and_suffix() {1102		let v = parse_str("std.test(2).field[0]");1103		assert_snapshot!(format!("{v:#?}"));1104	}11051106	#[test]1107	fn obj_extend() {1108		let v = parse_str("{} { x: 1 }");1109		assert_snapshot!(format!("{v:#?}"));1110	}11111112	#[test]1113	fn unary_ops() {1114		let v = parse_str("!a && !b");1115		assert_snapshot!(format!("{v:#?}"));1116	}11171118	#[test]1119	fn error_expr() {1120		let v = parse_str("error \"bad\"");1121		assert_snapshot!(format!("{v:#?}"));1122	}11231124	#[test]1125	fn slice() {1126		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1127		assert_snapshot!(format!("{v:#?}"));1128	}11291130	#[test]1131	#[cfg(not(feature = "exp-null-coaelse"))]1132	fn peg_snapshots() {1133		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1134			let input = fs::read_to_string(path).expect("read test file");1135			let source = Source::new_virtual("<test>".into(), IStr::empty());1136			let settings = ParserSettings { source };1137			let v = parse(&input, &settings).unwrap();1138			let v = format!("{v:#?}");1139			assert_snapshot!(v);1140		});1141	}1142}