git.delta.rocks / jrsonnet / refs/commits / 864d125a72a2

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, NumValue, ObjBody, ObjComp, ObjMembers, Slice,8	SliceDesc, 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<NumValue> {206	let text = p.text();207	let n: f64 = text208		.replace('_', "")209		.parse()210		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;211212	let v = match NumValue::try_from(n) {213		Ok(v) => v,214		Err(e) => return Err(p.error(format!("invalid number value: {e}"))),215	};216217	p.eat_any();218219	Ok(v)220}221222fn ident(p: &mut Parser<'_>) -> Result<IStr> {223	let text = p.text();224	p.eat(SyntaxKind::IDENT)?;225	Ok(IStr::from(text))226}227228fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {229	let t = match p.peek() {230		T![self] => LiteralType::This,231		T![super] => LiteralType::Super,232		T!['$'] => LiteralType::Dollar,233		T![null] => LiteralType::Null,234		T![true] => LiteralType::True,235		T![false] => LiteralType::False,236		_ => return None,237	};238	p.eat_any();239	Some(t)240}241242fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {243	p.eat(T![assert])?;244	let assertion = spanned(p, expr)?;245	let message = if p.try_eat(T![:]) {246		Some(expr(p)?)247	} else {248		None249	};250	Ok(AssertStmt { assertion, message })251}252253fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {254	let v = spanned(p, |p| p.eat(T![if]))?;255	let cond = expr(p)?;256	Ok(IfSpecData { span: v.span, cond })257}258259fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {260	let cond = if_spec_data(p)?;261	p.eat(T![then])?;262	let cond_then = expr(p)?;263	let cond_else = if p.try_eat(T![else]) {264		Some(expr(p)?)265	} else {266		None267	};268	Ok(IfElse {269		cond,270		cond_then,271		cond_else,272	})273}274275fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {276	p.eat(T![:])?;277	let end = if !p.at(T![:]) && !p.at(T![']']) {278		Some(spanned(p, expr)?)279	} else {280		None281	};282	let step = if p.try_eat(T![:]) {283		if p.at(T![']']) {284			None285		} else {286			Some(spanned(p, expr)?)287		}288	} else {289		None290	};291	Ok(SliceDesc { start, end, step })292}293294fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {295	if p.at(SyntaxKind::IDENT) {296		return Ok(Destruct::Full(ident(p)?));297	}298	#[cfg(not(feature = "exp-destruct"))]299	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));300	#[cfg(feature = "exp-destruct")]301	{302		if p.try_eat(T![?]) {303			return Ok(Destruct::Skip);304		}305		if p.at(T!['[']) {306			return destruct_array(p);307		}308		if p.at(T!['{']) {309			return destruct_object(p);310		}311		Err(p.error(format!(312			"expected destructure pattern, got {}",313			p.current_desc()314		)))315	}316}317318#[cfg(feature = "exp-destruct")]319fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {320	p.eat(T![...])?;321	if p.at(SyntaxKind::IDENT) {322		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))323	} else {324		Ok(jrsonnet_ir::DestructRest::Drop)325	}326}327328#[cfg(feature = "exp-destruct")]329fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {330	p.eat(T!['['])?;331	let mut start = Vec::new();332	let mut rest = None;333	let mut end = Vec::new();334	if !p.at(T![']']) {335		loop {336			if p.at(T![...]) {337				rest = Some(destruct_rest(p)?);338				if p.try_eat(T![,]) {339					if !p.at(T![']']) {340						loop {341							end.push(destruct(p)?);342							if !p.try_eat(T![,]) {343								break;344							}345							if p.at(T![']']) {346								break;347							}348						}349					}350				}351				break;352			}353			start.push(destruct(p)?);354			if !p.try_eat(T![,]) {355				break;356			}357			if p.at(T![']']) {358				break;359			}360		}361	}362	p.eat(T![']'])?;363	Ok(Destruct::Array { start, rest, end })364}365366#[cfg(feature = "exp-destruct")]367fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {368	p.eat(T!['{'])?;369	let mut fields = Vec::new();370	let mut rest = None;371	if !p.at(T!['}']) {372		loop {373			if p.at(T![...]) {374				rest = Some(destruct_rest(p)?);375				p.try_eat(T![,]);376				break;377			}378			let name = ident(p)?;379			let into = if p.try_eat(T![:]) {380				Some(destruct(p)?)381			} else {382				None383			};384			let default = if p.try_eat(T![=]) {385				Some(Rc::new(spanned(p, expr)?))386			} else {387				None388			};389			fields.push((name, into, default));390			if !p.try_eat(T![,]) {391				break;392			}393			if p.at(T!['}']) {394				break;395			}396		}397	}398	p.eat(T!['}'])?;399	Ok(Destruct::Object { fields, rest })400}401402fn params(p: &mut Parser<'_>) -> Result<ExprParams> {403	if p.at(T![')']) {404		return Ok(ExprParams::new(Vec::new()));405	}406	let mut result = Vec::new();407	loop {408		let d = destruct(p)?;409		let default = if p.try_eat(T![=]) {410			Some(Rc::new(expr(p)?))411		} else {412			None413		};414		result.push(ExprParam {415			destruct: d,416			default,417		});418		if !p.try_eat(T![,]) {419			break;420		}421		if p.at(T![')']) {422			break;423		}424	}425	Ok(ExprParams::new(result))426}427428fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {429	if p.at(T![')']) {430		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));431	}432	let mut unnamed = Vec::new();433	let mut names = Vec::new();434	let mut values = Vec::new();435	let mut named_started = false;436	loop {437		let is_named = p.at(SyntaxKind::IDENT) && {438			let next_offset = p.offset + 1;439			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]440		};441		if is_named {442			let name: IStr = ident(p)?;443			p.eat(T![=])?;444			let value = Rc::new(expr(p)?);445446			names.push(name);447			values.push(value);448			named_started = true;449		} else {450			if named_started {451				return Err(p.error("positional argument after named argument".into()));452			}453			unnamed.push(Rc::new(expr(p)?));454		}455		if !p.try_eat(T![,]) {456			break;457		}458		if p.at(T![')']) {459			break;460		}461	}462	Ok(ArgsDesc::new(unnamed, names, values))463}464465fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {466	#[cfg(feature = "exp-destruct")]467	{468		if !p.at(SyntaxKind::IDENT) {469			let d = destruct(p)?;470			p.eat(T![=])?;471			let value = Rc::new(expr(p)?);472			return Ok(BindSpec::Field { into: d, value });473		}474	}475	let name = ident(p)?;476	if p.try_eat(T!['(']) {477		let ps = params(p)?;478		p.eat(T![')'])?;479		p.eat(T![=])?;480		let value = Rc::new(expr(p)?);481		Ok(BindSpec::Function {482			name,483			params: ps,484			value,485		})486	} else {487		p.eat(T![=])?;488		let value = Rc::new(expr(p)?);489		Ok(BindSpec::Field {490			into: Destruct::Full(name),491			value,492		})493	}494}495496fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {497	p.eat(T![:])?;498	if p.try_eat(T![:]) {499		if p.try_eat(T![:]) {500			Ok(Visibility::Unhide)501		} else {502			Ok(Visibility::Hidden)503		}504	} else {505		Ok(Visibility::Normal)506	}507}508509fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {510	if p.at(SyntaxKind::IDENT) {511		Ok(FieldName::Fixed(ident(p)?))512	} else if is_string_token(p.peek()) {513		Ok(FieldName::Fixed(parse_string_content(p)?))514	} else if p.at(T!['[']) {515		p.eat(T!['['])?;516		let e = expr(p)?;517		p.eat(T![']'])?;518		Ok(FieldName::Dyn(e))519	} else {520		Err(p.error(format!("expected field name, got {}", p.current_desc())))521	}522}523524fn field(p: &mut Parser<'_>) -> Result<FieldMember> {525	let name = spanned(p, field_name)?;526527	if p.at(T!['(']) {528		p.eat(T!['('])?;529		let ps = params(p)?;530		p.eat(T![')'])?;531		let vis = visibility(p)?;532		let value = Rc::new(expr(p)?);533		Ok(FieldMember {534			name,535			plus: false,536			params: Some(ps),537			visibility: vis,538			value,539		})540	} else {541		let plus = p.try_eat(T![+]);542		let vis = visibility(p)?;543		let value = Rc::new(expr(p)?);544		Ok(FieldMember {545			name,546			plus,547			params: None,548			visibility: vis,549			value,550		})551	}552}553554fn member(p: &mut Parser<'_>) -> Result<Member> {555	if p.at(T![local]) {556		p.eat(T![local])?;557		Ok(Member::BindStmt(bind(p)?))558	} else if p.at(T![assert]) {559		Ok(Member::AssertStmt(assert_stmt(p)?))560	} else {561		Ok(Member::Field(field(p)?))562	}563}564565fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {566	p.eat(T![for])?;567	let d = destruct(p)?;568	p.eat(T![in])?;569	let over = expr(p)?;570	Ok(ForSpecData { destruct: d, over })571}572573fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {574	let mut specs = Vec::new();575	specs.push(CompSpec::ForSpec(for_spec(p)?));576	loop {577		if p.at(T![for]) {578			specs.push(CompSpec::ForSpec(for_spec(p)?));579		} else if p.at(T![if]) {580			let isd = if_spec_data(p)?;581			specs.push(CompSpec::IfSpec(isd));582		} else {583			break;584		}585	}586	Ok(specs)587}588589fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {590	if p.at(T!['}']) {591		return Ok(ObjBody::MemberList(ObjMembers {592			locals: Rc::new(Vec::new()),593			asserts: Rc::new(Vec::new()),594			fields: Vec::new(),595		}));596	}597598	let mut members = Vec::new();599	loop {600		members.push(member(p)?);601		if !p.try_eat(T![,]) {602			break;603		}604		if p.at(T!['}']) || p.at(T![for]) {605			break;606		}607	}608609	if p.at(T![for]) {610		let specs = compspecs(p)?;611		let mut locals = Vec::new();612		let mut field_member = None;613		for m in members {614			match m {615				Member::Field(f) => {616					if field_member.is_some() {617						return Err(618							p.error("object comprehension can only contain one field".into())619						);620					}621					field_member = Some(f);622				}623				Member::BindStmt(b) => locals.push(b),624				Member::AssertStmt(_) => {625					return Err(p.error("asserts are unsupported in object comprehension".into()));626				}627			}628		}629		Ok(ObjBody::ObjComp(ObjComp {630			locals: Rc::new(locals),631			field: Rc::new(632				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,633			),634			compspecs: specs,635		}))636	} else {637		let mut locals = Vec::new();638		let mut asserts = Vec::new();639		let mut fields = Vec::new();640		for m in members {641			match m {642				Member::Field(f) => fields.push(f),643				Member::BindStmt(b) => locals.push(b),644				Member::AssertStmt(a) => asserts.push(a),645			}646		}647		Ok(ObjBody::MemberList(ObjMembers {648			locals: Rc::new(locals),649			asserts: Rc::new(asserts),650			fields,651		}))652	}653}654655#[allow(clippy::too_many_lines)]656fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {657	if let Some(lit) = literal(p) {658		return Ok(Expr::Literal(lit));659	}660661	match p.peek() {662		SyntaxKind::STRING_DOUBLE663		| SyntaxKind::STRING_SINGLE664		| SyntaxKind::STRING_DOUBLE_VERBATIM665		| SyntaxKind::STRING_SINGLE_VERBATIM666		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),667668		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),669670		T!['('] => {671			p.eat(T!['('])?;672			let e = expr(p)?;673			p.eat(T![')'])?;674			Ok(e)675		}676677		T!['['] => {678			p.eat(T!['['])?;679			if p.at(T![']']) {680				p.eat(T![']'])?;681				return Ok(Expr::Arr(Rc::new(Vec::new())));682			}683			let first = expr(p)?;684			if p.at(T![for]) {685				let specs = compspecs(p)?;686				p.eat(T![']'])?;687				Ok(Expr::ArrComp(Rc::new(first), specs))688			} else if p.at(T![,]) && {689				let next = p.offset + 1;690				next < p.lexemes.len() && p.lexemes[next].kind == T![for]691			} {692				p.eat(T![,])?;693				let specs = compspecs(p)?;694				p.eat(T![']'])?;695				Ok(Expr::ArrComp(Rc::new(first), specs))696			} else {697				let mut elems = vec![first];698				while p.try_eat(T![,]) {699					if p.at(T![']']) {700						break;701					}702					elems.push(expr(p)?);703				}704				p.eat(T![']'])?;705				Ok(Expr::Arr(Rc::new(elems)))706			}707		}708709		T!['{'] => {710			p.eat(T!['{'])?;711			let body = objinside(p)?;712			p.eat(T!['}'])?;713			Ok(Expr::Obj(body))714		}715716		T![local] => {717			p.eat(T![local])?;718			let mut binds = Vec::new();719			loop {720				binds.push(bind(p)?);721				if !p.try_eat(T![,]) {722					break;723				}724			}725			p.eat(T![;])?;726			let body = expr(p)?;727			Ok(Expr::LocalExpr(binds, Box::new(body)))728		}729730		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),731732		T![function] => {733			p.eat(T![function])?;734			p.eat(T!['('])?;735			let ps = params(p)?;736			p.eat(T![')'])?;737			let body = expr(p)?;738			Ok(Expr::Function(ps, Rc::new(body)))739		}740741		T![assert] => {742			let a = assert_stmt(p)?;743			p.eat(T![;])?;744			let rest = expr(p)?;745			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))746		}747748		T![error] => {749			let span = spanned(p, |p| p.eat(T![error]))?;750			let e = expr(p)?;751			Ok(Expr::ErrorStmt(span.span, Box::new(e)))752		}753754		T![importstr] => {755			let kind = spanned(p, |p| {756				p.eat(T![importstr])?;757				Ok(ImportKind::Str)758			})?;759			let path = expr(p)?;760			Ok(Expr::Import(kind, Box::new(path)))761		}762763		T![importbin] => {764			let kind = spanned(p, |p| {765				p.eat(T![importbin])?;766				Ok(ImportKind::Bin)767			})?;768			let path = expr(p)?;769			Ok(Expr::Import(kind, Box::new(path)))770		}771772		T![import] => {773			let kind = spanned(p, |p| {774				p.eat(T![import])?;775				Ok(ImportKind::Normal)776			})?;777			let path = expr(p)?;778			Ok(Expr::Import(kind, Box::new(path)))779		}780781		SyntaxKind::IDENT => {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| Ok(Expr::Str(ident(p)?)))?;830					parts.push(IndexPart {831						span: id_spanned.span,832						value: id_spanned.value,833						null_coaelse: true,834					});835				}836			} else {837				return Err(p.error("expected '.' after '?'".into()));838			}839			continue;840		}841842		if p.at(T![.]) {843			p.eat(T![.])?;844			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;845			parts.push(IndexPart {846				span: id_spanned.span,847				value: id_spanned.value,848				#[cfg(feature = "exp-null-coaelse")]849				null_coaelse: false,850			});851		} else if p.at(T!['[']) {852			p.eat(T!['['])?;853854			if p.at(T![:]) {855				// Slice: flush index parts first, then handle slice856				flush_index_parts(&mut e, &mut parts);857				let slice = slice_desc(p, None)?;858				p.eat(T![']'])?;859				e = Expr::Slice(Box::new(Slice { value: e, slice }));860			} else {861				let idx = spanned(p, expr)?;862				if p.at(T![:]) {863					// Slice with start: flush index parts first864					flush_index_parts(&mut e, &mut parts);865					let slice = slice_desc(p, Some(idx))?;866					p.eat(T![']'])?;867					e = Expr::Slice(Box::new(Slice { value: e, slice }));868				} else {869					// Bracket index: add to parts870					p.eat(T![']'])?;871					parts.push(IndexPart {872						span: idx.span,873						value: idx.value,874						#[cfg(feature = "exp-null-coaelse")]875						null_coaelse: false,876					});877				}878			}879		} else if p.at(T!['(']) {880			flush_index_parts(&mut e, &mut parts);881			let args_spanned = spanned(p, |p| {882				p.eat(T!['('])?;883				let a = args(p)?;884				p.eat(T![')'])?;885				Ok(a)886			})?;887			let tailstrict = p.try_eat(T![tailstrict]);888			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);889		} else if p.at(T!['{']) {890			flush_index_parts(&mut e, &mut parts);891			p.eat(T!['{'])?;892			let body = objinside(p)?;893			p.eat(T!['}'])?;894			e = Expr::ObjExtend(Rc::new(e), body);895		} else {896			break;897		}898	}899900	flush_index_parts(&mut e, &mut parts);901	Ok(e)902}903904fn prefix_binding_power(op: UnaryOpType) -> u8 {905	match op {906		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,907	}908}909910fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {911	match op {912		BinaryOpType::Or => (2, 3),913		#[cfg(feature = "exp-null-coaelse")]914		BinaryOpType::NullCoaelse => (2, 3),915		BinaryOpType::And => (4, 5),916		BinaryOpType::BitOr => (6, 7),917		BinaryOpType::BitXor => (8, 9),918		BinaryOpType::BitAnd => (10, 11),919		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),920		BinaryOpType::Lt921		| BinaryOpType::Gt922		| BinaryOpType::Lte923		| BinaryOpType::Gte924		| BinaryOpType::In => (14, 15),925		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),926		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),927		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),928	}929}930931fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {932	match kind {933		T![+] => Some(UnaryOpType::Plus),934		T![-] => Some(UnaryOpType::Minus),935		T![!] => Some(UnaryOpType::Not),936		T![~] => Some(UnaryOpType::BitNot),937		_ => None,938	}939}940941fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {942	match p.peek() {943		T![||] => Some(BinaryOpType::Or),944		T![&&] => Some(BinaryOpType::And),945		T![|] => Some(BinaryOpType::BitOr),946		T![^] => Some(BinaryOpType::BitXor),947		T![&] => Some(BinaryOpType::BitAnd),948		T![==] => Some(BinaryOpType::Eq),949		T![!=] => Some(BinaryOpType::Neq),950		T![<] => Some(BinaryOpType::Lt),951		T![>] => Some(BinaryOpType::Gt),952		T![<=] => Some(BinaryOpType::Lte),953		T![>=] => Some(BinaryOpType::Gte),954		T![<<] => Some(BinaryOpType::Lhs),955		T![>>] => Some(BinaryOpType::Rhs),956		T![+] => Some(BinaryOpType::Add),957		T![-] => Some(BinaryOpType::Sub),958		T![*] => Some(BinaryOpType::Mul),959		T![/] => Some(BinaryOpType::Div),960		T![%] => Some(BinaryOpType::Mod),961		T![in] => Some(BinaryOpType::In),962		#[cfg(feature = "exp-null-coaelse")]963		T![??] => Some(BinaryOpType::NullCoaelse),964		_ => None,965	}966}967968fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {969	let mut lhs = if let Some(op) = unary_op(p.peek()) {970		p.eat_any();971		let rbp = prefix_binding_power(op);972		let rhs = expr_bp(p, rbp)?;973		Expr::UnaryOp(op, Box::new(rhs))974	} else {975		expr_suffix(p)?976	};977978	loop {979		if p.at_eof() {980			break;981		}982983		let Some(op) = binary_op(p) else {984			break;985		};986987		let (lbp, rbp) = infix_binding_power(op);988		if lbp < min_bp {989			break;990		}991992		p.eat_any();993		let rhs = expr_bp(p, rbp)?;994		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));995	}996997	Ok(lhs)998}9991000fn expr(p: &mut Parser<'_>) -> Result<Expr> {1001	expr_bp(p, 0)1002}10031004pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1005	let mut p = Parser::new(str, settings.source.clone());1006	for lexeme in &p.lexemes {1007		if let Some(desc) = lexeme.kind.error_description() {1008			return Err(ParseError {1009				message: desc.to_owned(),1010				location: lexeme.range,1011			});1012		}1013	}1014	let e = expr(&mut p)?;1015	if !p.at_eof() {1016		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1017	}1018	Ok(e)1019}10201021pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1022	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10231024	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1025}10261027#[cfg(test)]1028mod tests {1029	use std::fs;10301031	use insta::{assert_snapshot, glob};1032	use jrsonnet_ir::{IStr, Source};10331034	use super::*;10351036	fn parse_str(input: &str) -> Expr {1037		let source = Source::new_virtual("<test>".into(), input.into());1038		let settings = ParserSettings { source };1039		parse(input, &settings).unwrap()1040	}10411042	#[test]1043	#[cfg(not(feature = "exp-null-coaelse"))]1044	fn basic_test() {1045		let v = parse_str("assert true[false] : false ; true");1046		assert_snapshot!(format!("{v:#?}"));1047	}10481049	#[test]1050	fn literals() {1051		let v = parse_str("[null, true, false, self, super, $]");1052		assert_snapshot!(format!("{v:#?}"));1053	}10541055	#[test]1056	fn basic_math() {1057		let v = parse_str("2+2*2");1058		assert_snapshot!(format!("{v:#?}"));1059	}10601061	#[test]1062	fn underscore_numbers() {1063		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1064		assert_snapshot!(format!("{v:#?}"));1065	}10661067	#[test]1068	fn strings() {1069		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1070		assert_snapshot!(format!("{v:#?}"));1071	}10721073	#[test]1074	fn object() {1075		let v = parse_str("{a: 1, b:: 2, c::: 3}");1076		assert_snapshot!(format!("{v:#?}"));1077	}10781079	#[test]1080	fn function_and_call() {1081		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1082		assert_snapshot!(format!("{v:#?}"));1083	}10841085	#[test]1086	fn if_then_else() {1087		let v = parse_str("if true then 1 else 2");1088		assert_snapshot!(format!("{v:#?}"));1089	}10901091	#[test]1092	fn imports() {1093		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1094		assert_snapshot!(format!("{v:#?}"));1095	}10961097	#[test]1098	fn array_comp() {1099		let v = parse_str("[x for x in arr]");1100		assert_snapshot!(format!("{v:#?}"));1101	}11021103	#[test]1104	#[cfg(not(feature = "exp-null-coaelse"))]1105	fn index_and_suffix() {1106		let v = parse_str("std.test(2).field[0]");1107		assert_snapshot!(format!("{v:#?}"));1108	}11091110	#[test]1111	fn obj_extend() {1112		let v = parse_str("{} { x: 1 }");1113		assert_snapshot!(format!("{v:#?}"));1114	}11151116	#[test]1117	fn unary_ops() {1118		let v = parse_str("!a && !b");1119		assert_snapshot!(format!("{v:#?}"));1120	}11211122	#[test]1123	fn error_expr() {1124		let v = parse_str("error \"bad\"");1125		assert_snapshot!(format!("{v:#?}"));1126	}11271128	#[test]1129	fn slice() {1130		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1131		assert_snapshot!(format!("{v:#?}"));1132	}11331134	#[test]1135	#[cfg(not(feature = "exp-null-coaelse"))]1136	fn peg_snapshots() {1137		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1138			let input = fs::read_to_string(path).expect("read test file");1139			let source = Source::new_virtual("<test>".into(), IStr::empty());1140			let settings = ParserSettings { source };1141			let v = parse(&input, &settings).unwrap();1142			let v = format!("{v:#?}");1143			assert_snapshot!(v);1144		});1145	}1146}