git.delta.rocks / jrsonnet / refs/commits / 8885f2169203

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, SyntaxKind, T, collect_lexed_str_block};1112pub struct ParserSettings {13	pub source: Source,14}1516#[derive(Debug, Clone)]17pub struct ParseErrorLocation {18	pub offset: usize,19}2021#[derive(Debug, Clone)]22pub struct ParseError {23	pub message: String,24	pub location: ParseErrorLocation,25}2627impl std::fmt::Display for ParseError {28	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {29		write!(f, "{}", self.message)30	}31}3233type Result<T> = std::result::Result<T, ParseError>;3435struct Parser<'a> {36	lexemes: Vec<Lexeme<'a>>,37	offset: usize,38	source: Source,39}4041impl<'a> Parser<'a> {42	fn new(code: &'a str, source: Source) -> Self {43		Self {44			lexemes: Lexer::new(code)45				.filter(|l| {46					!matches!(47						l.kind,48						SyntaxKind::WHITESPACE49							| SyntaxKind::SINGLE_LINE_SLASH_COMMENT50							| SyntaxKind::SINGLE_LINE_HASH_COMMENT51							| SyntaxKind::MULTI_LINE_COMMENT52					)53				})54				.collect(),55			offset: 0,56			source,57		}58	}5960	fn peek(&self) -> SyntaxKind {61		if self.at_eof() {62			SyntaxKind::EOF63		} else {64			self.lexemes[self.offset].kind65		}66	}6768	fn text(&self) -> &'a str {69		self.lexemes[self.offset].text70	}7172	fn at(&self, kind: SyntaxKind) -> bool {73		!self.at_eof() && self.peek() == kind74	}7576	fn eat_any(&mut self) {77		self.offset += 1;78	}7980	fn at_eof(&self) -> bool {81		self.offset >= self.lexemes.len()82	}8384	fn try_eat(&mut self, t: SyntaxKind) -> bool {85		if self.at(t) {86			self.eat_any();87			return true;88		}89		false90	}9192	fn current_desc(&self) -> String {93		if self.at_eof() {94			return "end of file".to_owned();95		}96		let kind = self.peek();97		let text = self.text();98		let name = kind.display_name();99		if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {100			format!("{name} \"{text}\"")101		} else {102			name.to_owned()103		}104	}105106	fn eat(&mut self, t: SyntaxKind) -> Result<()> {107		if !self.at(t) {108			return Err(self.error(format!(109				"expected {}, got {}",110				t.display_name(),111				self.current_desc(),112			)));113		}114		self.eat_any();115		Ok(())116	}117118	fn span_start(&self) -> u32 {119		if self.at_eof() {120			if let Some(last) = self.lexemes.last() {121				return last.range.1;122			}123			return 0;124		}125		self.lexemes[self.offset].range.0126	}127128	fn span_end(&self) -> u32 {129		self.lexemes[self.offset - 1].range.1130	}131132	fn error(&self, message: String) -> ParseError {133		ParseError {134			location: ParseErrorLocation {135				offset: self.span_start() as usize,136			},137			message,138		}139	}140141	fn expect_ident(&mut self) -> Result<IStr> {142		if !self.at(SyntaxKind::IDENT) {143			return Err(self.error(format!("expected identifier, got {}", self.current_desc())));144		}145		let text = self.text();146		if is_reserved(text) {147			return Err(self.error(format!("expected identifier, got reserved word '{text}'")));148		}149		let s: IStr = text.into();150		self.eat_any();151		Ok(s)152	}153154	fn at_ident(&self) -> bool {155		self.at(SyntaxKind::IDENT) && !is_reserved(self.lexemes[self.offset].text)156	}157}158159fn is_reserved(s: &str) -> bool {160	matches!(161		s,162		"assert"163			| "else" | "error"164			| "false" | "for"165			| "function"166			| "if" | "import"167			| "importstr"168			| "importbin"169			| "in" | "local"170			| "null" | "tailstrict"171			| "then" | "self"172			| "super" | "true"173	)174}175176fn spanned<T: Acyclic>(177	p: &mut Parser<'_>,178	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,179) -> Result<Spanned<T>> {180	let start = p.span_start();181	let v = cb(p)?;182	let end = p.span_end();183	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))184}185186fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {187	let kind = p.peek();188	let text = p.text();189	let s = match kind {190		SyntaxKind::STRING_DOUBLE => {191			let inner = &text[1..text.len() - 1];192			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?193		}194		SyntaxKind::STRING_SINGLE => {195			let inner = &text[1..text.len() - 1];196			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?197		}198		SyntaxKind::STRING_DOUBLE_VERBATIM => {199			let inner = &text[2..text.len() - 1];200			inner.replace("\"\"", "\"")201		}202		SyntaxKind::STRING_SINGLE_VERBATIM => {203			let inner = &text[2..text.len() - 1];204			inner.replace("''", "'")205		}206		SyntaxKind::STRING_BLOCK => {207			let inner = &text[3..];208			let collected = collect_lexed_str_block(inner)209				.map_err(|_| p.error("invalid string block".into()))?;210			let mut result = String::new();211			for (i, line) in collected.lines.iter().enumerate() {212				if i > 0 {213					result.push('\n');214				}215				result.push_str(line);216			}217			if !collected.truncate {218				result.push('\n');219			}220			result221		}222		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),223	};224	p.eat_any();225	Ok(s.into())226}227228fn is_string_token(kind: SyntaxKind) -> bool {229	matches!(230		kind,231		SyntaxKind::STRING_DOUBLE232			| SyntaxKind::STRING_SINGLE233			| SyntaxKind::STRING_DOUBLE_VERBATIM234			| SyntaxKind::STRING_SINGLE_VERBATIM235			| SyntaxKind::STRING_BLOCK236	)237}238239fn parse_number(p: &mut Parser<'_>) -> Result<f64> {240	let text = p.text();241	let n: f64 = text242		.replace('_', "")243		.parse()244		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;245	if !n.is_finite() {246		return Err(p.error("numbers are finite".into()));247	}248	p.eat_any();249	Ok(n)250}251252fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {253	let t = match p.peek() {254		T![self] => LiteralType::This,255		T![super] => LiteralType::Super,256		T!['$'] => LiteralType::Dollar,257		T![null] => LiteralType::Null,258		T![true] => LiteralType::True,259		T![false] => LiteralType::False,260		_ => return None,261	};262	p.eat_any();263	Some(t)264}265266fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {267	p.eat(T![assert])?;268	let cond = spanned(p, expr)?;269	let msg = if p.try_eat(T![:]) {270		Some(spanned(p, expr)?)271	} else {272		None273	};274	Ok(AssertStmt(cond, msg))275}276277fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {278	let v = spanned(p, |p| p.eat(T![if]))?;279	let cond = expr(p)?;280	Ok(IfSpecData { span: v.span, cond })281}282283fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {284	let cond = if_spec_data(p)?;285	p.eat(T![then])?;286	let cond_then = expr(p)?;287	let cond_else = if p.try_eat(T![else]) {288		Some(expr(p)?)289	} else {290		None291	};292	Ok(IfElse {293		cond,294		cond_then,295		cond_else,296	})297}298299fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {300	p.eat(T![:])?;301	let end = if !p.at(T![:]) && !p.at(T![']']) {302		Some(spanned(p, expr)?)303	} else {304		None305	};306	let step = if p.try_eat(T![:]) {307		if p.at(T![']']) {308			None309		} else {310			Some(spanned(p, expr)?)311		}312	} else {313		None314	};315	Ok(SliceDesc { start, end, step })316}317318fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {319	if p.at_ident() {320		return Ok(Destruct::Full(p.expect_ident()?));321	}322	#[cfg(not(feature = "exp-destruct"))]323	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));324	#[cfg(feature = "exp-destruct")]325	{326		if p.try_eat(T![?]) {327			return Ok(Destruct::Skip);328		}329		if p.at(T!['[']) {330			return destruct_array(p);331		}332		if p.at(T!['{']) {333			return destruct_object(p);334		}335		Err(p.error(format!(336			"expected destructure pattern, got {}",337			p.current_desc()338		)))339	}340}341342#[cfg(feature = "exp-destruct")]343fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {344	p.eat(T![...])?;345	if p.at_ident() {346		Ok(jrsonnet_ir::DestructRest::Keep(p.expect_ident()?))347	} else {348		Ok(jrsonnet_ir::DestructRest::Drop)349	}350}351352#[cfg(feature = "exp-destruct")]353fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {354	p.eat(T!['['])?;355	let mut start = Vec::new();356	let mut rest = None;357	let mut end = Vec::new();358	if !p.at(T![']']) {359		loop {360			if p.at(T![...]) {361				rest = Some(destruct_rest(p)?);362				if p.try_eat(T![,]) {363					if !p.at(T![']']) {364						loop {365							end.push(destruct(p)?);366							if !p.try_eat(T![,]) {367								break;368							}369							if p.at(T![']']) {370								break;371							}372						}373					}374				}375				break;376			}377			start.push(destruct(p)?);378			if !p.try_eat(T![,]) {379				break;380			}381			if p.at(T![']']) {382				break;383			}384		}385	}386	p.eat(T![']'])?;387	Ok(Destruct::Array { start, rest, end })388}389390#[cfg(feature = "exp-destruct")]391fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {392	p.eat(T!['{'])?;393	let mut fields = Vec::new();394	let mut rest = None;395	if !p.at(T!['}']) {396		loop {397			if p.at(T![...]) {398				rest = Some(destruct_rest(p)?);399				p.try_eat(T![,]);400				break;401			}402			let name = p.expect_ident()?;403			let into = if p.try_eat(T![:]) {404				Some(destruct(p)?)405			} else {406				None407			};408			let default = if p.try_eat(T![=]) {409				Some(Rc::new(spanned(p, expr)?))410			} else {411				None412			};413			fields.push((name, into, default));414			if !p.try_eat(T![,]) {415				break;416			}417			if p.at(T!['}']) {418				break;419			}420		}421	}422	p.eat(T!['}'])?;423	Ok(Destruct::Object { fields, rest })424}425426fn params(p: &mut Parser<'_>) -> Result<ExprParams> {427	if p.at(T![')']) {428		return Ok(ExprParams::new(Vec::new()));429	}430	let mut result = Vec::new();431	loop {432		let d = destruct(p)?;433		let default = if p.try_eat(T![=]) {434			Some(Rc::new(expr(p)?))435		} else {436			None437		};438		result.push(ExprParam {439			destruct: d,440			default,441		});442		if !p.try_eat(T![,]) {443			break;444		}445		if p.at(T![')']) {446			break;447		}448	}449	Ok(ExprParams::new(result))450}451452fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {453	if p.at(T![')']) {454		return Ok(ArgsDesc::new(Vec::new(), Vec::new()));455	}456	let mut unnamed = Vec::new();457	let mut named = Vec::new();458	let mut named_started = false;459	loop {460		let is_named = p.at_ident() && {461			let next_offset = p.offset + 1;462			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=] && {463				let after_eq = next_offset + 1;464				after_eq >= p.lexemes.len() || p.lexemes[after_eq].kind != T![=]465			}466		};467		if is_named {468			let name: IStr = p.expect_ident()?;469			p.eat(T![=])?;470			let value = Rc::new(expr(p)?);471			named.push((name, value));472			named_started = true;473		} else {474			if named_started {475				return Err(p.error("positional argument after named argument".into()));476			}477			unnamed.push(Rc::new(expr(p)?));478		}479		if !p.try_eat(T![,]) {480			break;481		}482		if p.at(T![')']) {483			break;484		}485	}486	Ok(ArgsDesc::new(unnamed, named))487}488489fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {490	#[cfg(feature = "exp-destruct")]491	{492		if !p.at_ident() {493			let d = destruct(p)?;494			p.eat(T![=])?;495			let value = Rc::new(expr(p)?);496			return Ok(BindSpec::Field { into: d, value });497		}498	}499	let name = p.expect_ident()?;500	if p.try_eat(T!['(']) {501		let ps = params(p)?;502		p.eat(T![')'])?;503		p.eat(T![=])?;504		let value = Rc::new(expr(p)?);505		Ok(BindSpec::Function {506			name,507			params: ps,508			value,509		})510	} else {511		p.eat(T![=])?;512		let value = Rc::new(expr(p)?);513		Ok(BindSpec::Field {514			into: Destruct::Full(name),515			value,516		})517	}518}519520fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {521	p.eat(T![:])?;522	if p.try_eat(T![:]) {523		if p.try_eat(T![:]) {524			Ok(Visibility::Unhide)525		} else {526			Ok(Visibility::Hidden)527		}528	} else {529		Ok(Visibility::Normal)530	}531}532533fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {534	if p.at_ident() {535		Ok(FieldName::Fixed(p.expect_ident()?))536	} else if is_string_token(p.peek()) {537		Ok(FieldName::Fixed(parse_string_content(p)?))538	} else if p.at(T!['[']) {539		p.eat(T!['['])?;540		let e = expr(p)?;541		p.eat(T![']'])?;542		Ok(FieldName::Dyn(e))543	} else {544		Err(p.error(format!("expected field name, got {}", p.current_desc())))545	}546}547548fn field(p: &mut Parser<'_>) -> Result<FieldMember> {549	let name = spanned(p, field_name)?;550551	if p.at(T!['(']) {552		p.eat(T!['('])?;553		let ps = params(p)?;554		p.eat(T![')'])?;555		let vis = visibility(p)?;556		let value = Rc::new(expr(p)?);557		Ok(FieldMember {558			name,559			plus: false,560			params: Some(ps),561			visibility: vis,562			value,563		})564	} else {565		let plus = p.try_eat(T![+]);566		let vis = visibility(p)?;567		let value = Rc::new(expr(p)?);568		Ok(FieldMember {569			name,570			plus,571			params: None,572			visibility: vis,573			value,574		})575	}576}577578fn member(p: &mut Parser<'_>) -> Result<Member> {579	if p.at(T![local]) {580		p.eat(T![local])?;581		Ok(Member::BindStmt(bind(p)?))582	} else if p.at(T![assert]) {583		Ok(Member::AssertStmt(assert_stmt(p)?))584	} else {585		Ok(Member::Field(field(p)?))586	}587}588589fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {590	p.eat(T![for])?;591	let d = destruct(p)?;592	p.eat(T![in])?;593	let over = expr(p)?;594	Ok(ForSpecData { destruct: d, over })595}596597fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {598	let mut specs = Vec::new();599	specs.push(CompSpec::ForSpec(for_spec(p)?));600	loop {601		if p.at(T![for]) {602			specs.push(CompSpec::ForSpec(for_spec(p)?));603		} else if p.at(T![if]) {604			let isd = if_spec_data(p)?;605			specs.push(CompSpec::IfSpec(isd));606		} else {607			break;608		}609	}610	Ok(specs)611}612613fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {614	if p.at(T!['}']) {615		return Ok(ObjBody::MemberList(ObjMembers {616			locals: Rc::new(Vec::new()),617			asserts: Rc::new(Vec::new()),618			fields: Vec::new(),619		}));620	}621622	let mut members = Vec::new();623	loop {624		members.push(member(p)?);625		if !p.try_eat(T![,]) {626			break;627		}628		if p.at(T!['}']) || p.at(T![for]) {629			break;630		}631	}632633	if p.at(T![for]) {634		let specs = compspecs(p)?;635		let mut locals = Vec::new();636		let mut field_member = None;637		for m in members {638			match m {639				Member::Field(f) => {640					if field_member.is_some() {641						return Err(642							p.error("object comprehension can only contain one field".into())643						);644					}645					field_member = Some(f);646				}647				Member::BindStmt(b) => locals.push(b),648				Member::AssertStmt(_) => {649					return Err(p.error("asserts are unsupported in object comprehension".into()));650				}651			}652		}653		Ok(ObjBody::ObjComp(ObjComp {654			locals: Rc::new(locals),655			field: Rc::new(656				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,657			),658			compspecs: specs,659		}))660	} else {661		let mut locals = Vec::new();662		let mut asserts = Vec::new();663		let mut fields = Vec::new();664		for m in members {665			match m {666				Member::Field(f) => fields.push(f),667				Member::BindStmt(b) => locals.push(b),668				Member::AssertStmt(a) => asserts.push(a),669			}670		}671		Ok(ObjBody::MemberList(ObjMembers {672			locals: Rc::new(locals),673			asserts: Rc::new(asserts),674			fields,675		}))676	}677}678679fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {680	if let Some(lit) = literal(p) {681		return Ok(Expr::Literal(lit));682	}683684	match p.peek() {685		SyntaxKind::STRING_DOUBLE686		| SyntaxKind::STRING_SINGLE687		| SyntaxKind::STRING_DOUBLE_VERBATIM688		| SyntaxKind::STRING_SINGLE_VERBATIM689		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),690691		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),692693		T!['('] => {694			p.eat(T!['('])?;695			let e = expr(p)?;696			p.eat(T![')'])?;697			Ok(e)698		}699700		T!['['] => {701			p.eat(T!['['])?;702			if p.at(T![']']) {703				p.eat(T![']'])?;704				return Ok(Expr::Arr(Rc::new(Vec::new())));705			}706			let first = expr(p)?;707			if p.at(T![for]) {708				let specs = compspecs(p)?;709				p.eat(T![']'])?;710				Ok(Expr::ArrComp(Rc::new(first), specs))711			} else if p.at(T![,]) && {712				let next = p.offset + 1;713				next < p.lexemes.len() && p.lexemes[next].kind == T![for]714			} {715				p.eat(T![,])?;716				let specs = compspecs(p)?;717				p.eat(T![']'])?;718				Ok(Expr::ArrComp(Rc::new(first), specs))719			} else {720				let mut elems = vec![first];721				while p.try_eat(T![,]) {722					if p.at(T![']']) {723						break;724					}725					elems.push(expr(p)?);726				}727				p.eat(T![']'])?;728				Ok(Expr::Arr(Rc::new(elems)))729			}730		}731732		T!['{'] => {733			p.eat(T!['{'])?;734			let body = objinside(p)?;735			p.eat(T!['}'])?;736			Ok(Expr::Obj(body))737		}738739		T![local] => {740			p.eat(T![local])?;741			let mut binds = Vec::new();742			loop {743				binds.push(bind(p)?);744				if !p.try_eat(T![,]) {745					break;746				}747			}748			p.eat(T![;])?;749			let body = expr(p)?;750			Ok(Expr::LocalExpr(binds, Box::new(body)))751		}752753		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),754755		T![function] => {756			p.eat(T![function])?;757			p.eat(T!['('])?;758			let ps = params(p)?;759			p.eat(T![')'])?;760			let body = expr(p)?;761			Ok(Expr::Function(ps, Rc::new(body)))762		}763764		T![assert] => {765			let a = assert_stmt(p)?;766			p.eat(T![;])?;767			let rest = expr(p)?;768			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))769		}770771		T![error] => {772			let span = spanned(p, |p| p.eat(T![error]))?;773			let e = expr(p)?;774			Ok(Expr::ErrorStmt(span.span, Box::new(e)))775		}776777		T![importstr] => {778			let kind = spanned(p, |p| {779				p.eat(T![importstr])?;780				Ok(ImportKind::Str)781			})?;782			let path = expr(p)?;783			Ok(Expr::Import(kind, Box::new(path)))784		}785786		T![importbin] => {787			let kind = spanned(p, |p| {788				p.eat(T![importbin])?;789				Ok(ImportKind::Bin)790			})?;791			let path = expr(p)?;792			Ok(Expr::Import(kind, Box::new(path)))793		}794795		T![import] => {796			let kind = spanned(p, |p| {797				p.eat(T![import])?;798				Ok(ImportKind::Normal)799			})?;800			let path = expr(p)?;801			Ok(Expr::Import(kind, Box::new(path)))802		}803804		SyntaxKind::IDENT => {805			let text = p.text();806			if is_reserved(text) {807				return Err(p.error(format!("unexpected reserved word '{text}'")));808			}809			let n = spanned(p, |p| {810				let s: IStr = p.text().into();811				p.eat_any();812				Ok(s)813			})?;814			Ok(Expr::Var(n))815		}816817		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),818	}819}820821fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {822	if parts.is_empty() {823		return;824	}825	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));826	*e = Expr::Index {827		indexable: Box::new(old),828		parts: std::mem::take(parts),829	};830}831832fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {833	let mut e = expr_basic(p)?;834	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])835	// into a single Expr::Index. This is critical for null-coalesce semantics:836	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.837	let mut parts: Vec<IndexPart> = Vec::new();838839	loop {840		#[cfg(feature = "exp-null-coaelse")]841		if p.at(T![?]) {842			p.eat_any();843			if p.try_eat(T![.]) {844				if p.at(T!['[']) {845					// ?.[expr]846					p.eat(T!['['])?;847					let idx = spanned(p, expr)?;848					p.eat(T![']'])?;849					parts.push(IndexPart {850						span: idx.span,851						value: idx.value,852						null_coaelse: true,853					});854				} else {855					// ?.field856					let id_spanned = spanned(p, |p| {857						let name = p.expect_ident()?;858						Ok(Expr::Str(name))859					})?;860					parts.push(IndexPart {861						span: id_spanned.span,862						value: id_spanned.value,863						null_coaelse: true,864					});865				}866			} else {867				return Err(p.error("expected '.' after '?'".into()));868			}869			continue;870		}871872		if p.at(T![.]) {873			p.eat(T![.])?;874			let id_spanned = spanned(p, |p| {875				let name = p.expect_ident()?;876				Ok(Expr::Str(name))877			})?;878			parts.push(IndexPart {879				span: id_spanned.span,880				value: id_spanned.value,881				#[cfg(feature = "exp-null-coaelse")]882				null_coaelse: false,883			});884		} else if p.at(T!['[']) {885			p.eat(T!['['])?;886887			if p.at(T![:]) {888				// Slice: flush index parts first, then handle slice889				flush_index_parts(&mut e, &mut parts);890				let slice = slice_desc(p, None)?;891				p.eat(T![']'])?;892				e = Expr::Slice(Box::new(Slice { value: e, slice }));893			} else {894				let idx = spanned(p, expr)?;895				if p.at(T![:]) {896					// Slice with start: flush index parts first897					flush_index_parts(&mut e, &mut parts);898					let slice = slice_desc(p, Some(idx))?;899					p.eat(T![']'])?;900					e = Expr::Slice(Box::new(Slice { value: e, slice }));901				} else {902					// Bracket index: add to parts903					p.eat(T![']'])?;904					parts.push(IndexPart {905						span: idx.span,906						value: idx.value,907						#[cfg(feature = "exp-null-coaelse")]908						null_coaelse: false,909					});910				}911			}912		} else if p.at(T!['(']) {913			flush_index_parts(&mut e, &mut parts);914			let args_spanned = spanned(p, |p| {915				p.eat(T!['('])?;916				let a = args(p)?;917				p.eat(T![')'])?;918				Ok(a)919			})?;920			let tailstrict = p.try_eat(T![tailstrict]);921			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);922		} else if p.at(T!['{']) {923			flush_index_parts(&mut e, &mut parts);924			p.eat(T!['{'])?;925			let body = objinside(p)?;926			p.eat(T!['}'])?;927			e = Expr::ObjExtend(Rc::new(e), body);928		} else {929			break;930		}931	}932933	flush_index_parts(&mut e, &mut parts);934	Ok(e)935}936937fn prefix_binding_power(op: UnaryOpType) -> u8 {938	match op {939		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,940	}941}942943fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {944	match op {945		BinaryOpType::Or => (2, 3),946		#[cfg(feature = "exp-null-coaelse")]947		BinaryOpType::NullCoaelse => (2, 3),948		BinaryOpType::And => (4, 5),949		BinaryOpType::BitOr => (6, 7),950		BinaryOpType::BitXor => (8, 9),951		BinaryOpType::BitAnd => (10, 11),952		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),953		BinaryOpType::Lt954		| BinaryOpType::Gt955		| BinaryOpType::Lte956		| BinaryOpType::Gte957		| BinaryOpType::In => (14, 15),958		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),959		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),960		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),961	}962}963964fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {965	match kind {966		T![+] => Some(UnaryOpType::Plus),967		T![-] => Some(UnaryOpType::Minus),968		T![!] => Some(UnaryOpType::Not),969		T![~] => Some(UnaryOpType::BitNot),970		_ => None,971	}972}973974fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {975	match p.peek() {976		T![||] => Some(BinaryOpType::Or),977		T![&&] => Some(BinaryOpType::And),978		T![|] => Some(BinaryOpType::BitOr),979		T![^] => Some(BinaryOpType::BitXor),980		T![&] => Some(BinaryOpType::BitAnd),981		T![==] => Some(BinaryOpType::Eq),982		T![!=] => Some(BinaryOpType::Neq),983		T![<] => Some(BinaryOpType::Lt),984		T![>] => Some(BinaryOpType::Gt),985		T![<=] => Some(BinaryOpType::Lte),986		T![>=] => Some(BinaryOpType::Gte),987		T![<<] => Some(BinaryOpType::Lhs),988		T![>>] => Some(BinaryOpType::Rhs),989		T![+] => Some(BinaryOpType::Add),990		T![-] => Some(BinaryOpType::Sub),991		T![*] => Some(BinaryOpType::Mul),992		T![/] => Some(BinaryOpType::Div),993		T![%] => Some(BinaryOpType::Mod),994		T![in] => Some(BinaryOpType::In),995		#[cfg(feature = "exp-null-coaelse")]996		T![??] => Some(BinaryOpType::NullCoaelse),997		_ => None,998	}999}10001001fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {1002	let mut lhs = if let Some(op) = unary_op(p.peek()) {1003		p.eat_any();1004		let rbp = prefix_binding_power(op);1005		let rhs = expr_bp(p, rbp)?;1006		Expr::UnaryOp(op, Box::new(rhs))1007	} else {1008		expr_suffix(p)?1009	};10101011	loop {1012		if p.at_eof() {1013			break;1014		}10151016		let Some(op) = binary_op(p) else {1017			break;1018		};10191020		let (lbp, rbp) = infix_binding_power(op);1021		if lbp < min_bp {1022			break;1023		}10241025		p.eat_any();1026		let rhs = expr_bp(p, rbp)?;1027		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1028	}10291030	Ok(lhs)1031}10321033fn expr(p: &mut Parser<'_>) -> Result<Expr> {1034	expr_bp(p, 0)1035}10361037pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1038	let mut p = Parser::new(str, settings.source.clone());1039	for lexeme in &p.lexemes {1040		if let Some(desc) = lexeme.kind.error_description() {1041			return Err(ParseError {1042				message: desc.to_owned(),1043				location: ParseErrorLocation {1044					offset: lexeme.range.0 as usize,1045				},1046			});1047		}1048	}1049	let e = expr(&mut p)?;1050	if !p.at_eof() {1051		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1052	}1053	Ok(e)1054}10551056pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1057	let len = s.len();1058	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len as u32))1059}10601061#[cfg(test)]1062mod tests {1063	use std::fs;10641065	use insta::{assert_snapshot, glob};1066	use jrsonnet_ir::{IStr, Source};10671068	use super::*;10691070	fn parse_str(input: &str) -> Expr {1071		let source = Source::new_virtual("<test>".into(), input.into());1072		let settings = ParserSettings { source };1073		parse(input, &settings).unwrap()1074	}10751076	#[test]1077	#[cfg(not(feature = "exp-null-coaelse"))]1078	fn basic_test() {1079		let v = parse_str("assert true[false] : false ; true");1080		assert_snapshot!(format!("{v:#?}"));1081	}10821083	#[test]1084	fn literals() {1085		let v = parse_str("[null, true, false, self, super, $]");1086		assert_snapshot!(format!("{v:#?}"));1087	}10881089	#[test]1090	fn basic_math() {1091		let v = parse_str("2+2*2");1092		assert_snapshot!(format!("{v:#?}"));1093	}10941095	#[test]1096	fn underscore_numbers() {1097		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1098		assert_snapshot!(format!("{v:#?}"));1099	}11001101	#[test]1102	fn strings() {1103		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1104		assert_snapshot!(format!("{v:#?}"));1105	}11061107	#[test]1108	fn object() {1109		let v = parse_str("{a: 1, b:: 2, c::: 3}");1110		assert_snapshot!(format!("{v:#?}"));1111	}11121113	#[test]1114	fn function_and_call() {1115		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1116		assert_snapshot!(format!("{v:#?}"));1117	}11181119	#[test]1120	fn if_then_else() {1121		let v = parse_str("if true then 1 else 2");1122		assert_snapshot!(format!("{v:#?}"));1123	}11241125	#[test]1126	fn imports() {1127		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1128		assert_snapshot!(format!("{v:#?}"));1129	}11301131	#[test]1132	fn array_comp() {1133		let v = parse_str("[x for x in arr]");1134		assert_snapshot!(format!("{v:#?}"));1135	}11361137	#[test]1138	#[cfg(not(feature = "exp-null-coaelse"))]1139	fn index_and_suffix() {1140		let v = parse_str("std.test(2).field[0]");1141		assert_snapshot!(format!("{v:#?}"));1142	}11431144	#[test]1145	fn obj_extend() {1146		let v = parse_str("{} { x: 1 }");1147		assert_snapshot!(format!("{v:#?}"));1148	}11491150	#[test]1151	fn unary_ops() {1152		let v = parse_str("!a && !b");1153		assert_snapshot!(format!("{v:#?}"));1154	}11551156	#[test]1157	fn error_expr() {1158		let v = parse_str("error \"bad\"");1159		assert_snapshot!(format!("{v:#?}"));1160	}11611162	#[test]1163	fn slice() {1164		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1165		assert_snapshot!(format!("{v:#?}"));1166	}11671168	#[test]1169	#[cfg(not(feature = "exp-null-coaelse"))]1170	fn peg_snapshots() {1171		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1172			let input = fs::read_to_string(path).expect("read test file");1173			let source = Source::new_virtual("<test>".into(), IStr::empty());1174			let settings = ParserSettings { source };1175			let v = parse(&input, &settings).unwrap();1176			let v = format!("{v:#?}");1177			assert_snapshot!(v);1178		});1179	}1180}