git.delta.rocks / jrsonnet / refs/commits / 340c4675fc6f

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	}133}134135fn spanned<T: Acyclic>(136	p: &mut Parser<'_>,137	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,138) -> Result<Spanned<T>> {139	let start = p.span_start();140	let v = cb(p)?;141	let end = p.span_end();142	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))143}144145fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {146	let kind = p.peek();147	let text = p.text();148	let s = match kind {149		SyntaxKind::STRING_DOUBLE => {150			let inner = &text[1..text.len() - 1];151			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?152		}153		SyntaxKind::STRING_SINGLE => {154			let inner = &text[1..text.len() - 1];155			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?156		}157		SyntaxKind::STRING_DOUBLE_VERBATIM => {158			let inner = &text[2..text.len() - 1];159			inner.replace("\"\"", "\"")160		}161		SyntaxKind::STRING_SINGLE_VERBATIM => {162			let inner = &text[2..text.len() - 1];163			inner.replace("''", "'")164		}165		SyntaxKind::STRING_BLOCK => {166			let inner = &text[3..];167			let collected = collect_lexed_str_block(inner)168				.map_err(|_| p.error("invalid string block".into()))?;169			let mut result = String::new();170			for (i, line) in collected.lines.iter().enumerate() {171				if i > 0 {172					result.push('\n');173				}174				result.push_str(line);175			}176			if !collected.truncate {177				result.push('\n');178			}179			result180		}181		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),182	};183	p.eat_any();184	Ok(s.into())185}186187fn is_string_token(kind: SyntaxKind) -> bool {188	matches!(189		kind,190		SyntaxKind::STRING_DOUBLE191			| SyntaxKind::STRING_SINGLE192			| SyntaxKind::STRING_DOUBLE_VERBATIM193			| SyntaxKind::STRING_SINGLE_VERBATIM194			| SyntaxKind::STRING_BLOCK195	)196}197198fn parse_number(p: &mut Parser<'_>) -> Result<f64> {199	let text = p.text();200	let n: f64 = text201		.replace('_', "")202		.parse()203		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;204	if !n.is_finite() {205		return Err(p.error("numbers are finite".into()));206	}207	p.eat_any();208	Ok(n)209}210211fn ident(p: &mut Parser<'_>) -> Result<IStr> {212	let text = p.text();213	p.eat(SyntaxKind::IDENT)?;214	Ok(IStr::from(text))215}216217fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {218	let t = match p.peek() {219		T![self] => LiteralType::This,220		T![super] => LiteralType::Super,221		T!['$'] => LiteralType::Dollar,222		T![null] => LiteralType::Null,223		T![true] => LiteralType::True,224		T![false] => LiteralType::False,225		_ => return None,226	};227	p.eat_any();228	Some(t)229}230231fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {232	p.eat(T![assert])?;233	let cond = spanned(p, expr)?;234	let msg = if p.try_eat(T![:]) {235		Some(spanned(p, expr)?)236	} else {237		None238	};239	Ok(AssertStmt(cond, msg))240}241242fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {243	let v = spanned(p, |p| p.eat(T![if]))?;244	let cond = expr(p)?;245	Ok(IfSpecData { span: v.span, cond })246}247248fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {249	let cond = if_spec_data(p)?;250	p.eat(T![then])?;251	let cond_then = expr(p)?;252	let cond_else = if p.try_eat(T![else]) {253		Some(expr(p)?)254	} else {255		None256	};257	Ok(IfElse {258		cond,259		cond_then,260		cond_else,261	})262}263264fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {265	p.eat(T![:])?;266	let end = if !p.at(T![:]) && !p.at(T![']']) {267		Some(spanned(p, expr)?)268	} else {269		None270	};271	let step = if p.try_eat(T![:]) {272		if p.at(T![']']) {273			None274		} else {275			Some(spanned(p, expr)?)276		}277	} else {278		None279	};280	Ok(SliceDesc { start, end, step })281}282283fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {284	if p.at(SyntaxKind::IDENT) {285		return Ok(Destruct::Full(ident(p)?));286	}287	#[cfg(not(feature = "exp-destruct"))]288	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));289	#[cfg(feature = "exp-destruct")]290	{291		if p.try_eat(T![?]) {292			return Ok(Destruct::Skip);293		}294		if p.at(T!['[']) {295			return destruct_array(p);296		}297		if p.at(T!['{']) {298			return destruct_object(p);299		}300		Err(p.error(format!(301			"expected destructure pattern, got {}",302			p.current_desc()303		)))304	}305}306307#[cfg(feature = "exp-destruct")]308fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {309	p.eat(T![...])?;310	if p.at(SyntaxKind::IDENT) {311		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))312	} else {313		Ok(jrsonnet_ir::DestructRest::Drop)314	}315}316317#[cfg(feature = "exp-destruct")]318fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {319	p.eat(T!['['])?;320	let mut start = Vec::new();321	let mut rest = None;322	let mut end = Vec::new();323	if !p.at(T![']']) {324		loop {325			if p.at(T![...]) {326				rest = Some(destruct_rest(p)?);327				if p.try_eat(T![,]) {328					if !p.at(T![']']) {329						loop {330							end.push(destruct(p)?);331							if !p.try_eat(T![,]) {332								break;333							}334							if p.at(T![']']) {335								break;336							}337						}338					}339				}340				break;341			}342			start.push(destruct(p)?);343			if !p.try_eat(T![,]) {344				break;345			}346			if p.at(T![']']) {347				break;348			}349		}350	}351	p.eat(T![']'])?;352	Ok(Destruct::Array { start, rest, end })353}354355#[cfg(feature = "exp-destruct")]356fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {357	p.eat(T!['{'])?;358	let mut fields = Vec::new();359	let mut rest = None;360	if !p.at(T!['}']) {361		loop {362			if p.at(T![...]) {363				rest = Some(destruct_rest(p)?);364				p.try_eat(T![,]);365				break;366			}367			let name = ident(p)?;368			let into = if p.try_eat(T![:]) {369				Some(destruct(p)?)370			} else {371				None372			};373			let default = if p.try_eat(T![=]) {374				Some(Rc::new(spanned(p, expr)?))375			} else {376				None377			};378			fields.push((name, into, default));379			if !p.try_eat(T![,]) {380				break;381			}382			if p.at(T!['}']) {383				break;384			}385		}386	}387	p.eat(T!['}'])?;388	Ok(Destruct::Object { fields, rest })389}390391fn params(p: &mut Parser<'_>) -> Result<ExprParams> {392	if p.at(T![')']) {393		return Ok(ExprParams::new(Vec::new()));394	}395	let mut result = Vec::new();396	loop {397		let d = destruct(p)?;398		let default = if p.try_eat(T![=]) {399			Some(Rc::new(expr(p)?))400		} else {401			None402		};403		result.push(ExprParam {404			destruct: d,405			default,406		});407		if !p.try_eat(T![,]) {408			break;409		}410		if p.at(T![')']) {411			break;412		}413	}414	Ok(ExprParams::new(result))415}416417fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {418	if p.at(T![')']) {419		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));420	}421	let mut unnamed = Vec::new();422	let mut names = Vec::new();423	let mut values = Vec::new();424	let mut named_started = false;425	loop {426		let is_named = p.at(SyntaxKind::IDENT) && {427			let next_offset = p.offset + 1;428			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]429		};430		if is_named {431			let name: IStr = ident(p)?;432			p.eat(T![=])?;433			let value = Rc::new(expr(p)?);434435			names.push(name);436			values.push(value);437			named_started = true;438		} else {439			if named_started {440				return Err(p.error("positional argument after named argument".into()));441			}442			unnamed.push(Rc::new(expr(p)?));443		}444		if !p.try_eat(T![,]) {445			break;446		}447		if p.at(T![')']) {448			break;449		}450	}451	Ok(ArgsDesc::new(unnamed, names, values))452}453454fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {455	#[cfg(feature = "exp-destruct")]456	{457		if !p.at(SyntaxKind::IDENT) {458			let d = destruct(p)?;459			p.eat(T![=])?;460			let value = Rc::new(expr(p)?);461			return Ok(BindSpec::Field { into: d, value });462		}463	}464	let name = ident(p)?;465	if p.try_eat(T!['(']) {466		let ps = params(p)?;467		p.eat(T![')'])?;468		p.eat(T![=])?;469		let value = Rc::new(expr(p)?);470		Ok(BindSpec::Function {471			name,472			params: ps,473			value,474		})475	} else {476		p.eat(T![=])?;477		let value = Rc::new(expr(p)?);478		Ok(BindSpec::Field {479			into: Destruct::Full(name),480			value,481		})482	}483}484485fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {486	p.eat(T![:])?;487	if p.try_eat(T![:]) {488		if p.try_eat(T![:]) {489			Ok(Visibility::Unhide)490		} else {491			Ok(Visibility::Hidden)492		}493	} else {494		Ok(Visibility::Normal)495	}496}497498fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {499	if p.at(SyntaxKind::IDENT) {500		Ok(FieldName::Fixed(ident(p)?))501	} else if is_string_token(p.peek()) {502		Ok(FieldName::Fixed(parse_string_content(p)?))503	} else if p.at(T!['[']) {504		p.eat(T!['['])?;505		let e = expr(p)?;506		p.eat(T![']'])?;507		Ok(FieldName::Dyn(e))508	} else {509		Err(p.error(format!("expected field name, got {}", p.current_desc())))510	}511}512513fn field(p: &mut Parser<'_>) -> Result<FieldMember> {514	let name = spanned(p, field_name)?;515516	if p.at(T!['(']) {517		p.eat(T!['('])?;518		let ps = params(p)?;519		p.eat(T![')'])?;520		let vis = visibility(p)?;521		let value = Rc::new(expr(p)?);522		Ok(FieldMember {523			name,524			plus: false,525			params: Some(ps),526			visibility: vis,527			value,528		})529	} else {530		let plus = p.try_eat(T![+]);531		let vis = visibility(p)?;532		let value = Rc::new(expr(p)?);533		Ok(FieldMember {534			name,535			plus,536			params: None,537			visibility: vis,538			value,539		})540	}541}542543fn member(p: &mut Parser<'_>) -> Result<Member> {544	if p.at(T![local]) {545		p.eat(T![local])?;546		Ok(Member::BindStmt(bind(p)?))547	} else if p.at(T![assert]) {548		Ok(Member::AssertStmt(assert_stmt(p)?))549	} else {550		Ok(Member::Field(field(p)?))551	}552}553554fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {555	p.eat(T![for])?;556	let d = destruct(p)?;557	p.eat(T![in])?;558	let over = expr(p)?;559	Ok(ForSpecData { destruct: d, over })560}561562fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {563	let mut specs = Vec::new();564	specs.push(CompSpec::ForSpec(for_spec(p)?));565	loop {566		if p.at(T![for]) {567			specs.push(CompSpec::ForSpec(for_spec(p)?));568		} else if p.at(T![if]) {569			let isd = if_spec_data(p)?;570			specs.push(CompSpec::IfSpec(isd));571		} else {572			break;573		}574	}575	Ok(specs)576}577578fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {579	if p.at(T!['}']) {580		return Ok(ObjBody::MemberList(ObjMembers {581			locals: Rc::new(Vec::new()),582			asserts: Rc::new(Vec::new()),583			fields: Vec::new(),584		}));585	}586587	let mut members = Vec::new();588	loop {589		members.push(member(p)?);590		if !p.try_eat(T![,]) {591			break;592		}593		if p.at(T!['}']) || p.at(T![for]) {594			break;595		}596	}597598	if p.at(T![for]) {599		let specs = compspecs(p)?;600		let mut locals = Vec::new();601		let mut field_member = None;602		for m in members {603			match m {604				Member::Field(f) => {605					if field_member.is_some() {606						return Err(607							p.error("object comprehension can only contain one field".into())608						);609					}610					field_member = Some(f);611				}612				Member::BindStmt(b) => locals.push(b),613				Member::AssertStmt(_) => {614					return Err(p.error("asserts are unsupported in object comprehension".into()));615				}616			}617		}618		Ok(ObjBody::ObjComp(ObjComp {619			locals: Rc::new(locals),620			field: Rc::new(621				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,622			),623			compspecs: specs,624		}))625	} else {626		let mut locals = Vec::new();627		let mut asserts = Vec::new();628		let mut fields = Vec::new();629		for m in members {630			match m {631				Member::Field(f) => fields.push(f),632				Member::BindStmt(b) => locals.push(b),633				Member::AssertStmt(a) => asserts.push(a),634			}635		}636		Ok(ObjBody::MemberList(ObjMembers {637			locals: Rc::new(locals),638			asserts: Rc::new(asserts),639			fields,640		}))641	}642}643644#[allow(clippy::too_many_lines)]645fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {646	if let Some(lit) = literal(p) {647		return Ok(Expr::Literal(lit));648	}649650	match p.peek() {651		SyntaxKind::STRING_DOUBLE652		| SyntaxKind::STRING_SINGLE653		| SyntaxKind::STRING_DOUBLE_VERBATIM654		| SyntaxKind::STRING_SINGLE_VERBATIM655		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),656657		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),658659		T!['('] => {660			p.eat(T!['('])?;661			let e = expr(p)?;662			p.eat(T![')'])?;663			Ok(e)664		}665666		T!['['] => {667			p.eat(T!['['])?;668			if p.at(T![']']) {669				p.eat(T![']'])?;670				return Ok(Expr::Arr(Rc::new(Vec::new())));671			}672			let first = expr(p)?;673			if p.at(T![for]) {674				let specs = compspecs(p)?;675				p.eat(T![']'])?;676				Ok(Expr::ArrComp(Rc::new(first), specs))677			} else if p.at(T![,]) && {678				let next = p.offset + 1;679				next < p.lexemes.len() && p.lexemes[next].kind == T![for]680			} {681				p.eat(T![,])?;682				let specs = compspecs(p)?;683				p.eat(T![']'])?;684				Ok(Expr::ArrComp(Rc::new(first), specs))685			} else {686				let mut elems = vec![first];687				while p.try_eat(T![,]) {688					if p.at(T![']']) {689						break;690					}691					elems.push(expr(p)?);692				}693				p.eat(T![']'])?;694				Ok(Expr::Arr(Rc::new(elems)))695			}696		}697698		T!['{'] => {699			p.eat(T!['{'])?;700			let body = objinside(p)?;701			p.eat(T!['}'])?;702			Ok(Expr::Obj(body))703		}704705		T![local] => {706			p.eat(T![local])?;707			let mut binds = Vec::new();708			loop {709				binds.push(bind(p)?);710				if !p.try_eat(T![,]) {711					break;712				}713			}714			p.eat(T![;])?;715			let body = expr(p)?;716			Ok(Expr::LocalExpr(binds, Box::new(body)))717		}718719		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),720721		T![function] => {722			p.eat(T![function])?;723			p.eat(T!['('])?;724			let ps = params(p)?;725			p.eat(T![')'])?;726			let body = expr(p)?;727			Ok(Expr::Function(ps, Rc::new(body)))728		}729730		T![assert] => {731			let a = assert_stmt(p)?;732			p.eat(T![;])?;733			let rest = expr(p)?;734			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))735		}736737		T![error] => {738			let span = spanned(p, |p| p.eat(T![error]))?;739			let e = expr(p)?;740			Ok(Expr::ErrorStmt(span.span, Box::new(e)))741		}742743		T![importstr] => {744			let kind = spanned(p, |p| {745				p.eat(T![importstr])?;746				Ok(ImportKind::Str)747			})?;748			let path = expr(p)?;749			Ok(Expr::Import(kind, Box::new(path)))750		}751752		T![importbin] => {753			let kind = spanned(p, |p| {754				p.eat(T![importbin])?;755				Ok(ImportKind::Bin)756			})?;757			let path = expr(p)?;758			Ok(Expr::Import(kind, Box::new(path)))759		}760761		T![import] => {762			let kind = spanned(p, |p| {763				p.eat(T![import])?;764				Ok(ImportKind::Normal)765			})?;766			let path = expr(p)?;767			Ok(Expr::Import(kind, Box::new(path)))768		}769770		SyntaxKind::IDENT => {771			let n = spanned(p, |p| {772				let s: IStr = p.text().into();773				p.eat_any();774				Ok(s)775			})?;776			Ok(Expr::Var(n))777		}778779		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),780	}781}782783fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {784	if parts.is_empty() {785		return;786	}787	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));788	*e = Expr::Index {789		indexable: Box::new(old),790		parts: std::mem::take(parts),791	};792}793794fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {795	let mut e = expr_basic(p)?;796	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])797	// into a single Expr::Index. This is critical for null-coalesce semantics:798	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.799	let mut parts: Vec<IndexPart> = Vec::new();800801	loop {802		#[cfg(feature = "exp-null-coaelse")]803		if p.at(T![?]) {804			p.eat_any();805			if p.try_eat(T![.]) {806				if p.at(T!['[']) {807					// ?.[expr]808					p.eat(T!['['])?;809					let idx = spanned(p, expr)?;810					p.eat(T![']'])?;811					parts.push(IndexPart {812						span: idx.span,813						value: idx.value,814						null_coaelse: true,815					});816				} else {817					// ?.field818					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;819					parts.push(IndexPart {820						span: id_spanned.span,821						value: id_spanned.value,822						null_coaelse: true,823					});824				}825			} else {826				return Err(p.error("expected '.' after '?'".into()));827			}828			continue;829		}830831		if p.at(T![.]) {832			p.eat(T![.])?;833			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;834			parts.push(IndexPart {835				span: id_spanned.span,836				value: id_spanned.value,837				#[cfg(feature = "exp-null-coaelse")]838				null_coaelse: false,839			});840		} else if p.at(T!['[']) {841			p.eat(T!['['])?;842843			if p.at(T![:]) {844				// Slice: flush index parts first, then handle slice845				flush_index_parts(&mut e, &mut parts);846				let slice = slice_desc(p, None)?;847				p.eat(T![']'])?;848				e = Expr::Slice(Box::new(Slice { value: e, slice }));849			} else {850				let idx = spanned(p, expr)?;851				if p.at(T![:]) {852					// Slice with start: flush index parts first853					flush_index_parts(&mut e, &mut parts);854					let slice = slice_desc(p, Some(idx))?;855					p.eat(T![']'])?;856					e = Expr::Slice(Box::new(Slice { value: e, slice }));857				} else {858					// Bracket index: add to parts859					p.eat(T![']'])?;860					parts.push(IndexPart {861						span: idx.span,862						value: idx.value,863						#[cfg(feature = "exp-null-coaelse")]864						null_coaelse: false,865					});866				}867			}868		} else if p.at(T!['(']) {869			flush_index_parts(&mut e, &mut parts);870			let args_spanned = spanned(p, |p| {871				p.eat(T!['('])?;872				let a = args(p)?;873				p.eat(T![')'])?;874				Ok(a)875			})?;876			let tailstrict = p.try_eat(T![tailstrict]);877			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);878		} else if p.at(T!['{']) {879			flush_index_parts(&mut e, &mut parts);880			p.eat(T!['{'])?;881			let body = objinside(p)?;882			p.eat(T!['}'])?;883			e = Expr::ObjExtend(Rc::new(e), body);884		} else {885			break;886		}887	}888889	flush_index_parts(&mut e, &mut parts);890	Ok(e)891}892893fn prefix_binding_power(op: UnaryOpType) -> u8 {894	match op {895		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,896	}897}898899fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {900	match op {901		BinaryOpType::Or => (2, 3),902		#[cfg(feature = "exp-null-coaelse")]903		BinaryOpType::NullCoaelse => (2, 3),904		BinaryOpType::And => (4, 5),905		BinaryOpType::BitOr => (6, 7),906		BinaryOpType::BitXor => (8, 9),907		BinaryOpType::BitAnd => (10, 11),908		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),909		BinaryOpType::Lt910		| BinaryOpType::Gt911		| BinaryOpType::Lte912		| BinaryOpType::Gte913		| BinaryOpType::In => (14, 15),914		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),915		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),916		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),917	}918}919920fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {921	match kind {922		T![+] => Some(UnaryOpType::Plus),923		T![-] => Some(UnaryOpType::Minus),924		T![!] => Some(UnaryOpType::Not),925		T![~] => Some(UnaryOpType::BitNot),926		_ => None,927	}928}929930fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {931	match p.peek() {932		T![||] => Some(BinaryOpType::Or),933		T![&&] => Some(BinaryOpType::And),934		T![|] => Some(BinaryOpType::BitOr),935		T![^] => Some(BinaryOpType::BitXor),936		T![&] => Some(BinaryOpType::BitAnd),937		T![==] => Some(BinaryOpType::Eq),938		T![!=] => Some(BinaryOpType::Neq),939		T![<] => Some(BinaryOpType::Lt),940		T![>] => Some(BinaryOpType::Gt),941		T![<=] => Some(BinaryOpType::Lte),942		T![>=] => Some(BinaryOpType::Gte),943		T![<<] => Some(BinaryOpType::Lhs),944		T![>>] => Some(BinaryOpType::Rhs),945		T![+] => Some(BinaryOpType::Add),946		T![-] => Some(BinaryOpType::Sub),947		T![*] => Some(BinaryOpType::Mul),948		T![/] => Some(BinaryOpType::Div),949		T![%] => Some(BinaryOpType::Mod),950		T![in] => Some(BinaryOpType::In),951		#[cfg(feature = "exp-null-coaelse")]952		T![??] => Some(BinaryOpType::NullCoaelse),953		_ => None,954	}955}956957fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {958	let mut lhs = if let Some(op) = unary_op(p.peek()) {959		p.eat_any();960		let rbp = prefix_binding_power(op);961		let rhs = expr_bp(p, rbp)?;962		Expr::UnaryOp(op, Box::new(rhs))963	} else {964		expr_suffix(p)?965	};966967	loop {968		if p.at_eof() {969			break;970		}971972		let Some(op) = binary_op(p) else {973			break;974		};975976		let (lbp, rbp) = infix_binding_power(op);977		if lbp < min_bp {978			break;979		}980981		p.eat_any();982		let rhs = expr_bp(p, rbp)?;983		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));984	}985986	Ok(lhs)987}988989fn expr(p: &mut Parser<'_>) -> Result<Expr> {990	expr_bp(p, 0)991}992993pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {994	let mut p = Parser::new(str, settings.source.clone());995	for lexeme in &p.lexemes {996		if let Some(desc) = lexeme.kind.error_description() {997			return Err(ParseError {998				message: desc.to_owned(),999				location: lexeme.range,1000			});1001		}1002	}1003	let e = expr(&mut p)?;1004	if !p.at_eof() {1005		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1006	}1007	Ok(e)1008}10091010pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1011	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10121013	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1014}10151016#[cfg(test)]1017mod tests {1018	use std::fs;10191020	use insta::{assert_snapshot, glob};1021	use jrsonnet_ir::{IStr, Source};10221023	use super::*;10241025	fn parse_str(input: &str) -> Expr {1026		let source = Source::new_virtual("<test>".into(), input.into());1027		let settings = ParserSettings { source };1028		parse(input, &settings).unwrap()1029	}10301031	#[test]1032	#[cfg(not(feature = "exp-null-coaelse"))]1033	fn basic_test() {1034		let v = parse_str("assert true[false] : false ; true");1035		assert_snapshot!(format!("{v:#?}"));1036	}10371038	#[test]1039	fn literals() {1040		let v = parse_str("[null, true, false, self, super, $]");1041		assert_snapshot!(format!("{v:#?}"));1042	}10431044	#[test]1045	fn basic_math() {1046		let v = parse_str("2+2*2");1047		assert_snapshot!(format!("{v:#?}"));1048	}10491050	#[test]1051	fn underscore_numbers() {1052		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1053		assert_snapshot!(format!("{v:#?}"));1054	}10551056	#[test]1057	fn strings() {1058		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1059		assert_snapshot!(format!("{v:#?}"));1060	}10611062	#[test]1063	fn object() {1064		let v = parse_str("{a: 1, b:: 2, c::: 3}");1065		assert_snapshot!(format!("{v:#?}"));1066	}10671068	#[test]1069	fn function_and_call() {1070		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1071		assert_snapshot!(format!("{v:#?}"));1072	}10731074	#[test]1075	fn if_then_else() {1076		let v = parse_str("if true then 1 else 2");1077		assert_snapshot!(format!("{v:#?}"));1078	}10791080	#[test]1081	fn imports() {1082		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1083		assert_snapshot!(format!("{v:#?}"));1084	}10851086	#[test]1087	fn array_comp() {1088		let v = parse_str("[x for x in arr]");1089		assert_snapshot!(format!("{v:#?}"));1090	}10911092	#[test]1093	#[cfg(not(feature = "exp-null-coaelse"))]1094	fn index_and_suffix() {1095		let v = parse_str("std.test(2).field[0]");1096		assert_snapshot!(format!("{v:#?}"));1097	}10981099	#[test]1100	fn obj_extend() {1101		let v = parse_str("{} { x: 1 }");1102		assert_snapshot!(format!("{v:#?}"));1103	}11041105	#[test]1106	fn unary_ops() {1107		let v = parse_str("!a && !b");1108		assert_snapshot!(format!("{v:#?}"));1109	}11101111	#[test]1112	fn error_expr() {1113		let v = parse_str("error \"bad\"");1114		assert_snapshot!(format!("{v:#?}"));1115	}11161117	#[test]1118	fn slice() {1119		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1120		assert_snapshot!(format!("{v:#?}"));1121	}11221123	#[test]1124	#[cfg(not(feature = "exp-null-coaelse"))]1125	fn peg_snapshots() {1126		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1127			let input = fs::read_to_string(path).expect("read test file");1128			let source = Source::new_virtual("<test>".into(), IStr::empty());1129			let settings = ParserSettings { source };1130			let v = parse(&input, &settings).unwrap();1131			let v = format!("{v:#?}");1132			assert_snapshot!(v);1133		});1134	}1135}