git.delta.rocks / jrsonnet / refs/commits / 4e8e144facbc

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		ParseError {129			location: self.lexemes[self.offset].range,130			message,131		}132	}133134	fn expect_ident(&mut self) -> Result<IStr> {135		if !self.at(SyntaxKind::IDENT) {136			return Err(self.error(format!("expected identifier, got {}", self.current_desc())));137		}138		let text = self.text();139		let s: IStr = text.into();140		self.eat_any();141		Ok(s)142	}143144	fn at_ident(&self) -> bool {145		self.at(SyntaxKind::IDENT) && !is_reserved(self.lexemes[self.offset].text)146	}147}148149fn spanned<T: Acyclic>(150	p: &mut Parser<'_>,151	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,152) -> Result<Spanned<T>> {153	let start = p.span_start();154	let v = cb(p)?;155	let end = p.span_end();156	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))157}158159fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {160	let kind = p.peek();161	let text = p.text();162	let s = match kind {163		SyntaxKind::STRING_DOUBLE => {164			let inner = &text[1..text.len() - 1];165			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?166		}167		SyntaxKind::STRING_SINGLE => {168			let inner = &text[1..text.len() - 1];169			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?170		}171		SyntaxKind::STRING_DOUBLE_VERBATIM => {172			let inner = &text[2..text.len() - 1];173			inner.replace("\"\"", "\"")174		}175		SyntaxKind::STRING_SINGLE_VERBATIM => {176			let inner = &text[2..text.len() - 1];177			inner.replace("''", "'")178		}179		SyntaxKind::STRING_BLOCK => {180			let inner = &text[3..];181			let collected = collect_lexed_str_block(inner)182				.map_err(|_| p.error("invalid string block".into()))?;183			let mut result = String::new();184			for (i, line) in collected.lines.iter().enumerate() {185				if i > 0 {186					result.push('\n');187				}188				result.push_str(line);189			}190			if !collected.truncate {191				result.push('\n');192			}193			result194		}195		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),196	};197	p.eat_any();198	Ok(s.into())199}200201fn is_string_token(kind: SyntaxKind) -> bool {202	matches!(203		kind,204		SyntaxKind::STRING_DOUBLE205			| SyntaxKind::STRING_SINGLE206			| SyntaxKind::STRING_DOUBLE_VERBATIM207			| SyntaxKind::STRING_SINGLE_VERBATIM208			| SyntaxKind::STRING_BLOCK209	)210}211212fn parse_number(p: &mut Parser<'_>) -> Result<f64> {213	let text = p.text();214	let n: f64 = text215		.replace('_', "")216		.parse()217		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;218	if !n.is_finite() {219		return Err(p.error("numbers are finite".into()));220	}221	p.eat_any();222	Ok(n)223}224225fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {226	let t = match p.peek() {227		T![self] => LiteralType::This,228		T![super] => LiteralType::Super,229		T!['$'] => LiteralType::Dollar,230		T![null] => LiteralType::Null,231		T![true] => LiteralType::True,232		T![false] => LiteralType::False,233		_ => return None,234	};235	p.eat_any();236	Some(t)237}238239fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {240	p.eat(T![assert])?;241	let cond = spanned(p, expr)?;242	let msg = if p.try_eat(T![:]) {243		Some(spanned(p, expr)?)244	} else {245		None246	};247	Ok(AssertStmt(cond, msg))248}249250fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {251	let v = spanned(p, |p| p.eat(T![if]))?;252	let cond = expr(p)?;253	Ok(IfSpecData { span: v.span, cond })254}255256fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {257	let cond = if_spec_data(p)?;258	p.eat(T![then])?;259	let cond_then = expr(p)?;260	let cond_else = if p.try_eat(T![else]) {261		Some(expr(p)?)262	} else {263		None264	};265	Ok(IfElse {266		cond,267		cond_then,268		cond_else,269	})270}271272fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {273	p.eat(T![:])?;274	let end = if !p.at(T![:]) && !p.at(T![']']) {275		Some(spanned(p, expr)?)276	} else {277		None278	};279	let step = if p.try_eat(T![:]) {280		if p.at(T![']']) {281			None282		} else {283			Some(spanned(p, expr)?)284		}285	} else {286		None287	};288	Ok(SliceDesc { start, end, step })289}290291fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {292	if p.at_ident() {293		return Ok(Destruct::Full(p.expect_ident()?));294	}295	#[cfg(not(feature = "exp-destruct"))]296	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));297	#[cfg(feature = "exp-destruct")]298	{299		if p.try_eat(T![?]) {300			return Ok(Destruct::Skip);301		}302		if p.at(T!['[']) {303			return destruct_array(p);304		}305		if p.at(T!['{']) {306			return destruct_object(p);307		}308		Err(p.error(format!(309			"expected destructure pattern, got {}",310			p.current_desc()311		)))312	}313}314315#[cfg(feature = "exp-destruct")]316fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {317	p.eat(T![...])?;318	if p.at_ident() {319		Ok(jrsonnet_ir::DestructRest::Keep(p.expect_ident()?))320	} else {321		Ok(jrsonnet_ir::DestructRest::Drop)322	}323}324325#[cfg(feature = "exp-destruct")]326fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {327	p.eat(T!['['])?;328	let mut start = Vec::new();329	let mut rest = None;330	let mut end = Vec::new();331	if !p.at(T![']']) {332		loop {333			if p.at(T![...]) {334				rest = Some(destruct_rest(p)?);335				if p.try_eat(T![,]) {336					if !p.at(T![']']) {337						loop {338							end.push(destruct(p)?);339							if !p.try_eat(T![,]) {340								break;341							}342							if p.at(T![']']) {343								break;344							}345						}346					}347				}348				break;349			}350			start.push(destruct(p)?);351			if !p.try_eat(T![,]) {352				break;353			}354			if p.at(T![']']) {355				break;356			}357		}358	}359	p.eat(T![']'])?;360	Ok(Destruct::Array { start, rest, end })361}362363#[cfg(feature = "exp-destruct")]364fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {365	p.eat(T!['{'])?;366	let mut fields = Vec::new();367	let mut rest = None;368	if !p.at(T!['}']) {369		loop {370			if p.at(T![...]) {371				rest = Some(destruct_rest(p)?);372				p.try_eat(T![,]);373				break;374			}375			let name = p.expect_ident()?;376			let into = if p.try_eat(T![:]) {377				Some(destruct(p)?)378			} else {379				None380			};381			let default = if p.try_eat(T![=]) {382				Some(Rc::new(spanned(p, expr)?))383			} else {384				None385			};386			fields.push((name, into, default));387			if !p.try_eat(T![,]) {388				break;389			}390			if p.at(T!['}']) {391				break;392			}393		}394	}395	p.eat(T!['}'])?;396	Ok(Destruct::Object { fields, rest })397}398399fn params(p: &mut Parser<'_>) -> Result<ExprParams> {400	if p.at(T![')']) {401		return Ok(ExprParams::new(Vec::new()));402	}403	let mut result = Vec::new();404	loop {405		let d = destruct(p)?;406		let default = if p.try_eat(T![=]) {407			Some(Rc::new(expr(p)?))408		} else {409			None410		};411		result.push(ExprParam {412			destruct: d,413			default,414		});415		if !p.try_eat(T![,]) {416			break;417		}418		if p.at(T![')']) {419			break;420		}421	}422	Ok(ExprParams::new(result))423}424425fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {426	if p.at(T![')']) {427		return Ok(ArgsDesc::new(Vec::new(), Vec::new()));428	}429	let mut unnamed = Vec::new();430	let mut named = Vec::new();431	let mut named_started = false;432	loop {433		let is_named = p.at_ident() && {434			let next_offset = p.offset + 1;435			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=] && {436				let after_eq = next_offset + 1;437				after_eq >= p.lexemes.len() || p.lexemes[after_eq].kind != T![=]438			}439		};440		if is_named {441			let name: IStr = p.expect_ident()?;442			p.eat(T![=])?;443			let value = Rc::new(expr(p)?);444			named.push((name, value));445			named_started = true;446		} else {447			if named_started {448				return Err(p.error("positional argument after named argument".into()));449			}450			unnamed.push(Rc::new(expr(p)?));451		}452		if !p.try_eat(T![,]) {453			break;454		}455		if p.at(T![')']) {456			break;457		}458	}459	Ok(ArgsDesc::new(unnamed, named))460}461462fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {463	#[cfg(feature = "exp-destruct")]464	{465		if !p.at_ident() {466			let d = destruct(p)?;467			p.eat(T![=])?;468			let value = Rc::new(expr(p)?);469			return Ok(BindSpec::Field { into: d, value });470		}471	}472	let name = p.expect_ident()?;473	if p.try_eat(T!['(']) {474		let ps = params(p)?;475		p.eat(T![')'])?;476		p.eat(T![=])?;477		let value = Rc::new(expr(p)?);478		Ok(BindSpec::Function {479			name,480			params: ps,481			value,482		})483	} else {484		p.eat(T![=])?;485		let value = Rc::new(expr(p)?);486		Ok(BindSpec::Field {487			into: Destruct::Full(name),488			value,489		})490	}491}492493fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {494	p.eat(T![:])?;495	if p.try_eat(T![:]) {496		if p.try_eat(T![:]) {497			Ok(Visibility::Unhide)498		} else {499			Ok(Visibility::Hidden)500		}501	} else {502		Ok(Visibility::Normal)503	}504}505506fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {507	if p.at_ident() {508		Ok(FieldName::Fixed(p.expect_ident()?))509	} else if is_string_token(p.peek()) {510		Ok(FieldName::Fixed(parse_string_content(p)?))511	} else if p.at(T!['[']) {512		p.eat(T!['['])?;513		let e = expr(p)?;514		p.eat(T![']'])?;515		Ok(FieldName::Dyn(e))516	} else {517		Err(p.error(format!("expected field name, got {}", p.current_desc())))518	}519}520521fn field(p: &mut Parser<'_>) -> Result<FieldMember> {522	let name = spanned(p, field_name)?;523524	if p.at(T!['(']) {525		p.eat(T!['('])?;526		let ps = params(p)?;527		p.eat(T![')'])?;528		let vis = visibility(p)?;529		let value = Rc::new(expr(p)?);530		Ok(FieldMember {531			name,532			plus: false,533			params: Some(ps),534			visibility: vis,535			value,536		})537	} else {538		let plus = p.try_eat(T![+]);539		let vis = visibility(p)?;540		let value = Rc::new(expr(p)?);541		Ok(FieldMember {542			name,543			plus,544			params: None,545			visibility: vis,546			value,547		})548	}549}550551fn member(p: &mut Parser<'_>) -> Result<Member> {552	if p.at(T![local]) {553		p.eat(T![local])?;554		Ok(Member::BindStmt(bind(p)?))555	} else if p.at(T![assert]) {556		Ok(Member::AssertStmt(assert_stmt(p)?))557	} else {558		Ok(Member::Field(field(p)?))559	}560}561562fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {563	p.eat(T![for])?;564	let d = destruct(p)?;565	p.eat(T![in])?;566	let over = expr(p)?;567	Ok(ForSpecData { destruct: d, over })568}569570fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {571	let mut specs = Vec::new();572	specs.push(CompSpec::ForSpec(for_spec(p)?));573	loop {574		if p.at(T![for]) {575			specs.push(CompSpec::ForSpec(for_spec(p)?));576		} else if p.at(T![if]) {577			let isd = if_spec_data(p)?;578			specs.push(CompSpec::IfSpec(isd));579		} else {580			break;581		}582	}583	Ok(specs)584}585586fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {587	if p.at(T!['}']) {588		return Ok(ObjBody::MemberList(ObjMembers {589			locals: Rc::new(Vec::new()),590			asserts: Rc::new(Vec::new()),591			fields: Vec::new(),592		}));593	}594595	let mut members = Vec::new();596	loop {597		members.push(member(p)?);598		if !p.try_eat(T![,]) {599			break;600		}601		if p.at(T!['}']) || p.at(T![for]) {602			break;603		}604	}605606	if p.at(T![for]) {607		let specs = compspecs(p)?;608		let mut locals = Vec::new();609		let mut field_member = None;610		for m in members {611			match m {612				Member::Field(f) => {613					if field_member.is_some() {614						return Err(615							p.error("object comprehension can only contain one field".into())616						);617					}618					field_member = Some(f);619				}620				Member::BindStmt(b) => locals.push(b),621				Member::AssertStmt(_) => {622					return Err(p.error("asserts are unsupported in object comprehension".into()));623				}624			}625		}626		Ok(ObjBody::ObjComp(ObjComp {627			locals: Rc::new(locals),628			field: Rc::new(629				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,630			),631			compspecs: specs,632		}))633	} else {634		let mut locals = Vec::new();635		let mut asserts = Vec::new();636		let mut fields = Vec::new();637		for m in members {638			match m {639				Member::Field(f) => fields.push(f),640				Member::BindStmt(b) => locals.push(b),641				Member::AssertStmt(a) => asserts.push(a),642			}643		}644		Ok(ObjBody::MemberList(ObjMembers {645			locals: Rc::new(locals),646			asserts: Rc::new(asserts),647			fields,648		}))649	}650}651652fn 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 text = p.text();779			if is_reserved(text) {780				return Err(p.error(format!("unexpected reserved word '{text}'")));781			}782			let n = spanned(p, |p| {783				let s: IStr = p.text().into();784				p.eat_any();785				Ok(s)786			})?;787			Ok(Expr::Var(n))788		}789790		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),791	}792}793794fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {795	if parts.is_empty() {796		return;797	}798	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));799	*e = Expr::Index {800		indexable: Box::new(old),801		parts: std::mem::take(parts),802	};803}804805fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {806	let mut e = expr_basic(p)?;807	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])808	// into a single Expr::Index. This is critical for null-coalesce semantics:809	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.810	let mut parts: Vec<IndexPart> = Vec::new();811812	loop {813		#[cfg(feature = "exp-null-coaelse")]814		if p.at(T![?]) {815			p.eat_any();816			if p.try_eat(T![.]) {817				if p.at(T!['[']) {818					// ?.[expr]819					p.eat(T!['['])?;820					let idx = spanned(p, expr)?;821					p.eat(T![']'])?;822					parts.push(IndexPart {823						span: idx.span,824						value: idx.value,825						null_coaelse: true,826					});827				} else {828					// ?.field829					let id_spanned = spanned(p, |p| {830						let name = p.expect_ident()?;831						Ok(Expr::Str(name))832					})?;833					parts.push(IndexPart {834						span: id_spanned.span,835						value: id_spanned.value,836						null_coaelse: true,837					});838				}839			} else {840				return Err(p.error("expected '.' after '?'".into()));841			}842			continue;843		}844845		if p.at(T![.]) {846			p.eat(T![.])?;847			let id_spanned = spanned(p, |p| {848				let name = p.expect_ident()?;849				Ok(Expr::Str(name))850			})?;851			parts.push(IndexPart {852				span: id_spanned.span,853				value: id_spanned.value,854				#[cfg(feature = "exp-null-coaelse")]855				null_coaelse: false,856			});857		} else if p.at(T!['[']) {858			p.eat(T!['['])?;859860			if p.at(T![:]) {861				// Slice: flush index parts first, then handle slice862				flush_index_parts(&mut e, &mut parts);863				let slice = slice_desc(p, None)?;864				p.eat(T![']'])?;865				e = Expr::Slice(Box::new(Slice { value: e, slice }));866			} else {867				let idx = spanned(p, expr)?;868				if p.at(T![:]) {869					// Slice with start: flush index parts first870					flush_index_parts(&mut e, &mut parts);871					let slice = slice_desc(p, Some(idx))?;872					p.eat(T![']'])?;873					e = Expr::Slice(Box::new(Slice { value: e, slice }));874				} else {875					// Bracket index: add to parts876					p.eat(T![']'])?;877					parts.push(IndexPart {878						span: idx.span,879						value: idx.value,880						#[cfg(feature = "exp-null-coaelse")]881						null_coaelse: false,882					});883				}884			}885		} else if p.at(T!['(']) {886			flush_index_parts(&mut e, &mut parts);887			let args_spanned = spanned(p, |p| {888				p.eat(T!['('])?;889				let a = args(p)?;890				p.eat(T![')'])?;891				Ok(a)892			})?;893			let tailstrict = p.try_eat(T![tailstrict]);894			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);895		} else if p.at(T!['{']) {896			flush_index_parts(&mut e, &mut parts);897			p.eat(T!['{'])?;898			let body = objinside(p)?;899			p.eat(T!['}'])?;900			e = Expr::ObjExtend(Rc::new(e), body);901		} else {902			break;903		}904	}905906	flush_index_parts(&mut e, &mut parts);907	Ok(e)908}909910fn prefix_binding_power(op: UnaryOpType) -> u8 {911	match op {912		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,913	}914}915916fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {917	match op {918		BinaryOpType::Or => (2, 3),919		#[cfg(feature = "exp-null-coaelse")]920		BinaryOpType::NullCoaelse => (2, 3),921		BinaryOpType::And => (4, 5),922		BinaryOpType::BitOr => (6, 7),923		BinaryOpType::BitXor => (8, 9),924		BinaryOpType::BitAnd => (10, 11),925		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),926		BinaryOpType::Lt927		| BinaryOpType::Gt928		| BinaryOpType::Lte929		| BinaryOpType::Gte930		| BinaryOpType::In => (14, 15),931		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),932		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),933		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),934	}935}936937fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {938	match kind {939		T![+] => Some(UnaryOpType::Plus),940		T![-] => Some(UnaryOpType::Minus),941		T![!] => Some(UnaryOpType::Not),942		T![~] => Some(UnaryOpType::BitNot),943		_ => None,944	}945}946947fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {948	match p.peek() {949		T![||] => Some(BinaryOpType::Or),950		T![&&] => Some(BinaryOpType::And),951		T![|] => Some(BinaryOpType::BitOr),952		T![^] => Some(BinaryOpType::BitXor),953		T![&] => Some(BinaryOpType::BitAnd),954		T![==] => Some(BinaryOpType::Eq),955		T![!=] => Some(BinaryOpType::Neq),956		T![<] => Some(BinaryOpType::Lt),957		T![>] => Some(BinaryOpType::Gt),958		T![<=] => Some(BinaryOpType::Lte),959		T![>=] => Some(BinaryOpType::Gte),960		T![<<] => Some(BinaryOpType::Lhs),961		T![>>] => Some(BinaryOpType::Rhs),962		T![+] => Some(BinaryOpType::Add),963		T![-] => Some(BinaryOpType::Sub),964		T![*] => Some(BinaryOpType::Mul),965		T![/] => Some(BinaryOpType::Div),966		T![%] => Some(BinaryOpType::Mod),967		T![in] => Some(BinaryOpType::In),968		#[cfg(feature = "exp-null-coaelse")]969		T![??] => Some(BinaryOpType::NullCoaelse),970		_ => None,971	}972}973974fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {975	let mut lhs = if let Some(op) = unary_op(p.peek()) {976		p.eat_any();977		let rbp = prefix_binding_power(op);978		let rhs = expr_bp(p, rbp)?;979		Expr::UnaryOp(op, Box::new(rhs))980	} else {981		expr_suffix(p)?982	};983984	loop {985		if p.at_eof() {986			break;987		}988989		let Some(op) = binary_op(p) else {990			break;991		};992993		let (lbp, rbp) = infix_binding_power(op);994		if lbp < min_bp {995			break;996		}997998		p.eat_any();999		let rhs = expr_bp(p, rbp)?;1000		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1001	}10021003	Ok(lhs)1004}10051006fn expr(p: &mut Parser<'_>) -> Result<Expr> {1007	expr_bp(p, 0)1008}10091010pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1011	let mut p = Parser::new(str, settings.source.clone());1012	for lexeme in &p.lexemes {1013		if let Some(desc) = lexeme.kind.error_description() {1014			return Err(ParseError {1015				message: desc.to_owned(),1016				location: lexeme.range,1017			});1018		}1019	}1020	let e = expr(&mut p)?;1021	if !p.at_eof() {1022		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1023	}1024	Ok(e)1025}10261027pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1028	let len = s.len();1029	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len as u32))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}