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

1use jrsonnet_gcmodule::Acyclic;2use jrsonnet_ir::{3	ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec, Destruct, Expr,4	ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse, IfSpecData,5	ImportKind, IndexPart, LiteralType, Member, NumValue, ObjBody, ObjComp, ObjMembers, Slice,6	SliceDesc, Source, Span, Spanned, UnaryOpType, Visibility, unescape,7};8use jrsonnet_lexer::{Lexeme, Lexer, Span as LexSpan, SyntaxKind, T, collect_lexed_str_block};910pub struct ParserSettings {11	pub source: Source,12}1314#[derive(Debug, Clone)]15pub struct ParseError {16	pub message: String,17	pub location: Span,18}1920impl std::fmt::Display for ParseError {21	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {22		write!(f, "{}", self.message)23	}24}2526type Result<T> = std::result::Result<T, ParseError>;2728struct Parser<'a> {29	lexemes: Vec<Lexeme<'a>>,30	offset: usize,31	source: Source,32}3334impl<'a> Parser<'a> {35	fn new(code: &'a str, source: Source) -> Self {36		Self {37			lexemes: Lexer::new(code)38				.filter(|l| {39					!matches!(40						l.kind,41						SyntaxKind::WHITESPACE42							| SyntaxKind::SINGLE_LINE_SLASH_COMMENT43							| SyntaxKind::SINGLE_LINE_HASH_COMMENT44							| SyntaxKind::MULTI_LINE_COMMENT45					)46				})47				.collect(),48			offset: 0,49			source,50		}51	}5253	fn peek(&self) -> SyntaxKind {54		if self.at_eof() {55			SyntaxKind::EOF56		} else {57			self.lexemes[self.offset].kind58		}59	}6061	fn text(&self) -> &'a str {62		self.lexemes[self.offset].text63	}6465	fn at(&self, kind: SyntaxKind) -> bool {66		!self.at_eof() && self.peek() == kind67	}6869	fn eat_any(&mut self) {70		self.offset += 1;71	}7273	fn at_eof(&self) -> bool {74		self.offset >= self.lexemes.len()75	}7677	fn try_eat(&mut self, t: SyntaxKind) -> bool {78		if self.at(t) {79			self.eat_any();80			return true;81		}82		false83	}8485	fn current_desc(&self) -> String {86		if self.at_eof() {87			return "end of file".to_owned();88		}89		let kind = self.peek();90		let text = self.text();91		let name = kind.display_name();92		if matches!(kind, SyntaxKind::IDENT | SyntaxKind::FLOAT) {93			format!("{name} \"{text}\"")94		} else {95			name.to_owned()96		}97	}9899	fn eat(&mut self, t: SyntaxKind) -> Result<()> {100		if !self.at(t) {101			return Err(self.error(format!(102				"expected {}, got {}",103				t.display_name(),104				self.current_desc(),105			)));106		}107		self.eat_any();108		Ok(())109	}110111	fn span_start(&self) -> u32 {112		if self.at_eof() {113			if let Some(last) = self.lexemes.last() {114				return last.range.1;115			}116			return 0;117		}118		self.lexemes[self.offset].range.0119	}120121	fn span_end(&self) -> u32 {122		self.lexemes[self.offset - 1].range.1123	}124125	fn error(&self, message: String) -> ParseError {126		if self.offset == self.lexemes.len() {127			let pos = self.lexemes.last().map_or(0, |v| v.range.1);128			return ParseError {129				location: Span(self.source.clone(), pos, pos),130				message,131			};132		}133		let LexSpan(start, end) = self.lexemes[self.offset].range;134		ParseError {135			location: Span(self.source.clone(), start, end),136			message,137		}138	}139}140141fn spanned<T: Acyclic>(142	p: &mut Parser<'_>,143	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,144) -> Result<Spanned<T>> {145	let start = p.span_start();146	let v = cb(p)?;147	let end = p.span_end();148	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))149}150151fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {152	let kind = p.peek();153	let text = p.text();154	let s = match kind {155		SyntaxKind::STRING_DOUBLE => {156			let inner = &text[1..text.len() - 1];157			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?158		}159		SyntaxKind::STRING_SINGLE => {160			let inner = &text[1..text.len() - 1];161			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?162		}163		SyntaxKind::STRING_DOUBLE_VERBATIM => {164			let inner = &text[2..text.len() - 1];165			inner.replace("\"\"", "\"")166		}167		SyntaxKind::STRING_SINGLE_VERBATIM => {168			let inner = &text[2..text.len() - 1];169			inner.replace("''", "'")170		}171		SyntaxKind::STRING_BLOCK => {172			let inner = &text[3..];173			let collected = collect_lexed_str_block(inner)174				.map_err(|_| p.error("invalid string block".into()))?;175			let mut result = String::new();176			for (i, line) in collected.lines.iter().enumerate() {177				if i > 0 {178					result.push('\n');179				}180				result.push_str(line);181			}182			if !collected.truncate {183				result.push('\n');184			}185			result186		}187		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),188	};189	p.eat_any();190	Ok(s.into())191}192193fn is_string_token(kind: SyntaxKind) -> bool {194	matches!(195		kind,196		SyntaxKind::STRING_DOUBLE197			| SyntaxKind::STRING_SINGLE198			| SyntaxKind::STRING_DOUBLE_VERBATIM199			| SyntaxKind::STRING_SINGLE_VERBATIM200			| SyntaxKind::STRING_BLOCK201	)202}203204fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {205	let text = p.text();206	let n: f64 = text207		.replace('_', "")208		.parse()209		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;210211	let v = match NumValue::try_from(n) {212		Ok(v) => v,213		Err(e) => return Err(p.error(format!("invalid number value: {e}"))),214	};215216	p.eat_any();217218	Ok(v)219}220221fn ident(p: &mut Parser<'_>) -> Result<IStr> {222	let text = p.text();223	p.eat(SyntaxKind::IDENT)?;224	Ok(IStr::from(text))225}226227fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {228	let t = match p.peek() {229		T![self] => LiteralType::This,230		T![super] => LiteralType::Super,231		T!['$'] => LiteralType::Dollar,232		T![null] => LiteralType::Null,233		T![true] => LiteralType::True,234		T![false] => LiteralType::False,235		_ => return None,236	};237	p.eat_any();238	Some(t)239}240241fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {242	p.eat(T![assert])?;243	let assertion = spanned(p, expr)?;244	let message = if p.try_eat(T![:]) {245		Some(expr(p)?)246	} else {247		None248	};249	Ok(AssertStmt { assertion, message })250}251252fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {253	let v = spanned(p, |p| p.eat(T![if]))?;254	let cond = expr(p)?;255	Ok(IfSpecData { span: v.span, cond })256}257258fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {259	let cond = if_spec_data(p)?;260	p.eat(T![then])?;261	let cond_then = expr(p)?;262	let cond_else = if p.try_eat(T![else]) {263		Some(expr(p)?)264	} else {265		None266	};267	Ok(IfElse {268		cond,269		cond_then,270		cond_else,271	})272}273274fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {275	p.eat(T![:])?;276	let end = if !p.at(T![:]) && !p.at(T![']']) {277		Some(spanned(p, expr)?)278	} else {279		None280	};281	let step = if p.try_eat(T![:]) {282		if p.at(T![']']) {283			None284		} else {285			Some(spanned(p, expr)?)286		}287	} else {288		None289	};290	Ok(SliceDesc { start, end, step })291}292293fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {294	if p.at(SyntaxKind::IDENT) {295		return Ok(Destruct::Full(spanned(p, ident)?));296	}297	#[cfg(not(feature = "exp-destruct"))]298	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));299	#[cfg(feature = "exp-destruct")]300	{301		if p.try_eat(T![?]) {302			return Ok(Destruct::Skip);303		}304		if p.at(T!['[']) {305			return destruct_array(p);306		}307		if p.at(T!['{']) {308			return destruct_object(p);309		}310		Err(p.error(format!(311			"expected destructure pattern, got {}",312			p.current_desc()313		)))314	}315}316317#[cfg(feature = "exp-destruct")]318fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {319	p.eat(T![...])?;320	if p.at(SyntaxKind::IDENT) {321		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))322	} else {323		Ok(jrsonnet_ir::DestructRest::Drop)324	}325}326327#[cfg(feature = "exp-destruct")]328fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {329	p.eat(T!['['])?;330	let mut start = Vec::new();331	let mut rest = None;332	let mut end = Vec::new();333	if !p.at(T![']']) {334		loop {335			if p.at(T![...]) {336				rest = Some(destruct_rest(p)?);337				if p.try_eat(T![,]) {338					if !p.at(T![']']) {339						loop {340							end.push(destruct(p)?);341							if !p.try_eat(T![,]) {342								break;343							}344							if p.at(T![']']) {345								break;346							}347						}348					}349				}350				break;351			}352			start.push(destruct(p)?);353			if !p.try_eat(T![,]) {354				break;355			}356			if p.at(T![']']) {357				break;358			}359		}360	}361	p.eat(T![']'])?;362	Ok(Destruct::Array { start, rest, end })363}364365#[cfg(feature = "exp-destruct")]366fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {367	p.eat(T!['{'])?;368	let mut fields = Vec::new();369	let mut rest = None;370	if !p.at(T!['}']) {371		loop {372			if p.at(T![...]) {373				rest = Some(destruct_rest(p)?);374				p.try_eat(T![,]);375				break;376			}377			let name = ident(p)?;378			let into = if p.try_eat(T![:]) {379				Some(destruct(p)?)380			} else {381				None382			};383			let default = if p.try_eat(T![=]) {384				Some(spanned(p, expr)?)385			} else {386				None387			};388			fields.push((name, into, default));389			if !p.try_eat(T![,]) {390				break;391			}392			if p.at(T!['}']) {393				break;394			}395		}396	}397	p.eat(T!['}'])?;398	Ok(Destruct::Object { fields, rest })399}400401fn params(p: &mut Parser<'_>) -> Result<ExprParams> {402	if p.at(T![')']) {403		return Ok(ExprParams::new(Vec::new()));404	}405	let mut result = Vec::new();406	loop {407		let d = destruct(p)?;408		let default = if p.try_eat(T![=]) {409			Some(expr(p)?)410		} else {411			None412		};413		result.push(ExprParam {414			destruct: d,415			default,416		});417		if !p.try_eat(T![,]) {418			break;419		}420		if p.at(T![')']) {421			break;422		}423	}424	Ok(ExprParams::new(result))425}426427fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {428	if p.at(T![')']) {429		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));430	}431	let mut unnamed = Vec::new();432	let mut names = Vec::new();433	let mut values = Vec::new();434	let mut named_started = false;435	loop {436		let is_named = p.at(SyntaxKind::IDENT) && {437			let next_offset = p.offset + 1;438			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]439		};440		if is_named {441			let name: IStr = ident(p)?;442			p.eat(T![=])?;443444			names.push(name);445			values.push(expr(p)?);446			named_started = true;447		} else {448			if named_started {449				return Err(p.error("positional argument after named argument".into()));450			}451			unnamed.push(expr(p)?);452		}453		if !p.try_eat(T![,]) {454			break;455		}456		if p.at(T![')']) {457			break;458		}459	}460	Ok(ArgsDesc::new(unnamed, names, values))461}462463fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {464	#[cfg(feature = "exp-destruct")]465	{466		if !p.at(SyntaxKind::IDENT) {467			let d = destruct(p)?;468			p.eat(T![=])?;469			return Ok(BindSpec::Field {470				into: d,471				value: expr(p)?,472			});473		}474	}475	let name_spanned = spanned(p, ident)?;476	if p.try_eat(T!['(']) {477		let ps = params(p)?;478		p.eat(T![')'])?;479		p.eat(T![=])?;480		Ok(BindSpec::Function {481			name: name_spanned.value,482			params: ps,483			value: expr(p)?,484		})485	} else {486		p.eat(T![=])?;487		Ok(BindSpec::Field {488			into: Destruct::Full(name_spanned),489			value: expr(p)?,490		})491	}492}493494fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {495	p.eat(T![:])?;496	if p.try_eat(T![:]) {497		if p.try_eat(T![:]) {498			Ok(Visibility::Unhide)499		} else {500			Ok(Visibility::Hidden)501		}502	} else {503		Ok(Visibility::Normal)504	}505}506507fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {508	if p.at(SyntaxKind::IDENT) {509		Ok(FieldName::Fixed(ident(p)?))510	} else if is_string_token(p.peek()) {511		Ok(FieldName::Fixed(parse_string_content(p)?))512	} else if p.at(T!['[']) {513		p.eat(T!['['])?;514		let e = expr(p)?;515		p.eat(T![']'])?;516		Ok(FieldName::Dyn(e))517	} else {518		Err(p.error(format!("expected field name, got {}", p.current_desc())))519	}520}521522fn field(p: &mut Parser<'_>) -> Result<FieldMember> {523	let name = spanned(p, field_name)?;524525	if p.at(T!['(']) {526		p.eat(T!['('])?;527		let ps = params(p)?;528		p.eat(T![')'])?;529		let vis = visibility(p)?;530		Ok(FieldMember {531			name,532			plus: false,533			params: Some(ps),534			visibility: vis,535			value: expr(p)?,536		})537	} else {538		let plus = p.try_eat(T![+]);539		let vis = visibility(p)?;540		Ok(FieldMember {541			name,542			plus,543			params: None,544			visibility: vis,545			value: expr(p)?,546		})547	}548}549550fn member(p: &mut Parser<'_>) -> Result<Member> {551	if p.at(T![local]) {552		p.eat(T![local])?;553		Ok(Member::BindStmt(bind(p)?))554	} else if p.at(T![assert]) {555		Ok(Member::AssertStmt(assert_stmt(p)?))556	} else {557		Ok(Member::Field(field(p)?))558	}559}560561fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {562	p.eat(T![for])?;563	let d = destruct(p)?;564	p.eat(T![in])?;565	let over = expr(p)?;566	Ok(ForSpecData { destruct: d, over })567}568569fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {570	let mut specs = Vec::new();571	specs.push(CompSpec::ForSpec(for_spec(p)?));572	loop {573		if p.at(T![for]) {574			specs.push(CompSpec::ForSpec(for_spec(p)?));575		} else if p.at(T![if]) {576			let isd = if_spec_data(p)?;577			specs.push(CompSpec::IfSpec(isd));578		} else {579			break;580		}581	}582	Ok(specs)583}584585fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {586	if p.at(T!['}']) {587		return Ok(ObjBody::MemberList(ObjMembers {588			locals: Vec::new(),589			asserts: Vec::new(),590			fields: Vec::new(),591		}));592	}593594	let mut members = Vec::new();595	loop {596		members.push(member(p)?);597		if !p.try_eat(T![,]) {598			break;599		}600		if p.at(T!['}']) || p.at(T![for]) {601			break;602		}603	}604605	if p.at(T![for]) {606		let specs = compspecs(p)?;607		let mut locals = Vec::new();608		let mut field_member = None;609		for m in members {610			match m {611				Member::Field(f) => {612					if field_member.is_some() {613						return Err(614							p.error("object comprehension can only contain one field".into())615						);616					}617					field_member = Some(f);618				}619				Member::BindStmt(b) => locals.push(b),620				Member::AssertStmt(_) => {621					return Err(p.error("asserts are unsupported in object comprehension".into()));622				}623			}624		}625		Ok(ObjBody::ObjComp(ObjComp {626			locals,627			field: Box::new(628				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,629			),630			compspecs: specs,631		}))632	} else {633		let mut locals = Vec::new();634		let mut asserts = Vec::new();635		let mut fields = Vec::new();636		for m in members {637			match m {638				Member::Field(f) => fields.push(f),639				Member::BindStmt(b) => locals.push(b),640				Member::AssertStmt(a) => asserts.push(a),641			}642		}643		Ok(ObjBody::MemberList(ObjMembers {644			locals,645			asserts,646			fields,647		}))648	}649}650651#[allow(clippy::too_many_lines)]652fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {653	if let Some(lit) = literal(p) {654		return Ok(Expr::Literal(lit));655	}656657	match p.peek() {658		SyntaxKind::STRING_DOUBLE659		| SyntaxKind::STRING_SINGLE660		| SyntaxKind::STRING_DOUBLE_VERBATIM661		| SyntaxKind::STRING_SINGLE_VERBATIM662		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),663664		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),665666		T!['('] => {667			p.eat(T!['('])?;668			let e = expr(p)?;669			p.eat(T![')'])?;670			Ok(e)671		}672673		T!['['] => {674			p.eat(T!['['])?;675			if p.at(T![']']) {676				p.eat(T![']'])?;677				return Ok(Expr::Arr(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(Box::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(Box::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(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				if p.at(T![;]) {717					break;718				}719				binds.push(bind(p)?);720				if !p.try_eat(T![,]) {721					break;722				}723			}724			p.eat(T![;])?;725			let body = expr(p)?;726			Ok(Expr::LocalExpr(binds, Box::new(body)))727		}728729		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),730731		T![function] => {732			p.eat(T![function])?;733			p.eat(T!['('])?;734			let ps = params(p)?;735			p.eat(T![')'])?;736			let body = expr(p)?;737			Ok(Expr::Function(ps, Box::new(body)))738		}739740		T![assert] => {741			let a = assert_stmt(p)?;742			p.eat(T![;])?;743			let rest = expr(p)?;744			Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))745		}746747		T![error] => {748			let span = spanned(p, |p| p.eat(T![error]))?;749			let e = expr(p)?;750			Ok(Expr::ErrorStmt(span.span, Box::new(e)))751		}752753		T![importstr] => {754			let kind = spanned(p, |p| {755				p.eat(T![importstr])?;756				Ok(ImportKind::Str)757			})?;758			let path = expr(p)?;759			Ok(Expr::Import(kind, Box::new(path)))760		}761762		T![importbin] => {763			let kind = spanned(p, |p| {764				p.eat(T![importbin])?;765				Ok(ImportKind::Bin)766			})?;767			let path = expr(p)?;768			Ok(Expr::Import(kind, Box::new(path)))769		}770771		T![import] => {772			let kind = spanned(p, |p| {773				p.eat(T![import])?;774				Ok(ImportKind::Normal)775			})?;776			let path = expr(p)?;777			Ok(Expr::Import(kind, Box::new(path)))778		}779780		SyntaxKind::IDENT => {781			let n = spanned(p, |p| {782				let s: IStr = p.text().into();783				p.eat_any();784				Ok(s)785			})?;786			Ok(Expr::Var(n))787		}788789		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),790	}791}792793fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {794	if parts.is_empty() {795		return;796	}797	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));798	*e = Expr::Index {799		indexable: Box::new(old),800		parts: std::mem::take(parts),801	};802}803804fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {805	let mut e = expr_basic(p)?;806	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])807	// into a single Expr::Index. This is critical for null-coalesce semantics:808	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.809	let mut parts: Vec<IndexPart> = Vec::new();810811	loop {812		#[cfg(feature = "exp-null-coaelse")]813		if p.at(T![?]) {814			p.eat_any();815			if p.try_eat(T![.]) {816				if p.at(T!['[']) {817					// ?.[expr]818					p.eat(T!['['])?;819					let idx = spanned(p, expr)?;820					p.eat(T![']'])?;821					parts.push(IndexPart {822						span: idx.span,823						value: idx.value,824						null_coaelse: true,825					});826				} else {827					// ?.field828					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;829					parts.push(IndexPart {830						span: id_spanned.span,831						value: id_spanned.value,832						null_coaelse: true,833					});834				}835			} else {836				return Err(p.error("expected '.' after '?'".into()));837			}838			continue;839		}840841		if p.at(T![.]) {842			p.eat(T![.])?;843			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;844			parts.push(IndexPart {845				span: id_spanned.span,846				value: id_spanned.value,847				#[cfg(feature = "exp-null-coaelse")]848				null_coaelse: false,849			});850		} else if p.at(T!['[']) {851			p.eat(T!['['])?;852853			if p.at(T![:]) {854				// Slice: flush index parts first, then handle slice855				flush_index_parts(&mut e, &mut parts);856				let slice = slice_desc(p, None)?;857				p.eat(T![']'])?;858				e = Expr::Slice(Box::new(Slice { value: e, slice }));859			} else {860				let idx = spanned(p, expr)?;861				if p.at(T![:]) {862					// Slice with start: flush index parts first863					flush_index_parts(&mut e, &mut parts);864					let slice = slice_desc(p, Some(idx))?;865					p.eat(T![']'])?;866					e = Expr::Slice(Box::new(Slice { value: e, slice }));867				} else {868					// Bracket index: add to parts869					p.eat(T![']'])?;870					parts.push(IndexPart {871						span: idx.span,872						value: idx.value,873						#[cfg(feature = "exp-null-coaelse")]874						null_coaelse: false,875					});876				}877			}878		} else if p.at(T!['(']) {879			flush_index_parts(&mut e, &mut parts);880			let args_spanned = spanned(p, |p| {881				p.eat(T!['('])?;882				let a = args(p)?;883				p.eat(T![')'])?;884				Ok(a)885			})?;886			let tailstrict = p.try_eat(T![tailstrict]);887			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);888		} else if p.at(T!['{']) {889			flush_index_parts(&mut e, &mut parts);890			p.eat(T!['{'])?;891			let body = objinside(p)?;892			p.eat(T!['}'])?;893			e = Expr::ObjExtend(Box::new(e), body);894		} else {895			break;896		}897	}898899	flush_index_parts(&mut e, &mut parts);900	Ok(e)901}902903fn prefix_binding_power(op: UnaryOpType) -> u8 {904	match op {905		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,906	}907}908909fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {910	match op {911		BinaryOpType::Or => (2, 3),912		#[cfg(feature = "exp-null-coaelse")]913		BinaryOpType::NullCoaelse => (2, 3),914		BinaryOpType::And => (4, 5),915		BinaryOpType::BitOr => (6, 7),916		BinaryOpType::BitXor => (8, 9),917		BinaryOpType::BitAnd => (10, 11),918		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),919		BinaryOpType::Lt920		| BinaryOpType::Gt921		| BinaryOpType::Lte922		| BinaryOpType::Gte923		| BinaryOpType::In => (14, 15),924		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),925		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),926		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),927	}928}929930fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {931	match kind {932		T![+] => Some(UnaryOpType::Plus),933		T![-] => Some(UnaryOpType::Minus),934		T![!] => Some(UnaryOpType::Not),935		T![~] => Some(UnaryOpType::BitNot),936		_ => None,937	}938}939940fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {941	match p.peek() {942		T![||] => Some(BinaryOpType::Or),943		T![&&] => Some(BinaryOpType::And),944		T![|] => Some(BinaryOpType::BitOr),945		T![^] => Some(BinaryOpType::BitXor),946		T![&] => Some(BinaryOpType::BitAnd),947		T![==] => Some(BinaryOpType::Eq),948		T![!=] => Some(BinaryOpType::Neq),949		T![<] => Some(BinaryOpType::Lt),950		T![>] => Some(BinaryOpType::Gt),951		T![<=] => Some(BinaryOpType::Lte),952		T![>=] => Some(BinaryOpType::Gte),953		T![<<] => Some(BinaryOpType::Lhs),954		T![>>] => Some(BinaryOpType::Rhs),955		T![+] => Some(BinaryOpType::Add),956		T![-] => Some(BinaryOpType::Sub),957		T![*] => Some(BinaryOpType::Mul),958		T![/] => Some(BinaryOpType::Div),959		T![%] => Some(BinaryOpType::Mod),960		T![in] => Some(BinaryOpType::In),961		#[cfg(feature = "exp-null-coaelse")]962		T![??] => Some(BinaryOpType::NullCoaelse),963		_ => None,964	}965}966967fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {968	let mut lhs = if let Some(op) = unary_op(p.peek()) {969		p.eat_any();970		let rbp = prefix_binding_power(op);971		let rhs = expr_bp(p, rbp)?;972		Expr::UnaryOp(op, Box::new(rhs))973	} else {974		expr_suffix(p)?975	};976977	loop {978		if p.at_eof() {979			break;980		}981982		let Some(op) = binary_op(p) else {983			break;984		};985986		let (lbp, rbp) = infix_binding_power(op);987		if lbp < min_bp {988			break;989		}990991		p.eat_any();992		let rhs = expr_bp(p, rbp)?;993		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));994	}995996	Ok(lhs)997}998999fn expr(p: &mut Parser<'_>) -> Result<Expr> {1000	expr_bp(p, 0)1001}10021003pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1004	let mut p = Parser::new(str, settings.source.clone());1005	for lexeme in &p.lexemes {1006		if let Some(desc) = lexeme.kind.error_description() {1007			return Err(ParseError {1008				message: desc.to_owned(),1009				location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1010			});1011		}1012	}1013	let e = expr(&mut p)?;1014	if !p.at_eof() {1015		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1016	}1017	Ok(e)1018}10191020pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1021	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10221023	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1024}10251026#[cfg(test)]1027mod tests {1028	use std::fs;10291030	use insta::{assert_snapshot, glob};1031	use jrsonnet_ir::{IStr, Source};10321033	use super::*;10341035	fn parse_str(input: &str) -> Expr {1036		let source = Source::new_virtual("<test>".into(), input.into());1037		let settings = ParserSettings { source };1038		parse(input, &settings).unwrap()1039	}10401041	#[test]1042	#[cfg(not(feature = "exp-null-coaelse"))]1043	fn basic_test() {1044		let v = parse_str("assert true[false] : false ; true");1045		assert_snapshot!(format!("{v:#?}"));1046	}10471048	#[test]1049	fn literals() {1050		let v = parse_str("[null, true, false, self, super, $]");1051		assert_snapshot!(format!("{v:#?}"));1052	}10531054	#[test]1055	fn basic_math() {1056		let v = parse_str("2+2*2");1057		assert_snapshot!(format!("{v:#?}"));1058	}10591060	#[test]1061	fn underscore_numbers() {1062		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1063		assert_snapshot!(format!("{v:#?}"));1064	}10651066	#[test]1067	fn strings() {1068		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1069		assert_snapshot!(format!("{v:#?}"));1070	}10711072	#[test]1073	fn object() {1074		let v = parse_str("{a: 1, b:: 2, c::: 3}");1075		assert_snapshot!(format!("{v:#?}"));1076	}10771078	#[test]1079	fn function_and_call() {1080		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1081		assert_snapshot!(format!("{v:#?}"));1082	}10831084	#[test]1085	fn if_then_else() {1086		let v = parse_str("if true then 1 else 2");1087		assert_snapshot!(format!("{v:#?}"));1088	}10891090	#[test]1091	fn imports() {1092		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1093		assert_snapshot!(format!("{v:#?}"));1094	}10951096	#[test]1097	fn array_comp() {1098		let v = parse_str("[x for x in arr]");1099		assert_snapshot!(format!("{v:#?}"));1100	}11011102	#[test]1103	#[cfg(not(feature = "exp-null-coaelse"))]1104	fn index_and_suffix() {1105		let v = parse_str("std.test(2).field[0]");1106		assert_snapshot!(format!("{v:#?}"));1107	}11081109	#[test]1110	fn obj_extend() {1111		let v = parse_str("{} { x: 1 }");1112		assert_snapshot!(format!("{v:#?}"));1113	}11141115	#[test]1116	fn unary_ops() {1117		let v = parse_str("!a && !b");1118		assert_snapshot!(format!("{v:#?}"));1119	}11201121	#[test]1122	fn error_expr() {1123		let v = parse_str("error \"bad\"");1124		assert_snapshot!(format!("{v:#?}"));1125	}11261127	#[test]1128	fn slice() {1129		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1130		assert_snapshot!(format!("{v:#?}"));1131	}11321133	#[test]1134	#[cfg(not(feature = "exp-null-coaelse"))]1135	fn peg_snapshots() {1136		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1137			let input = fs::read_to_string(path).expect("read test file");1138			let source = Source::new_virtual("<test>".into(), IStr::empty());1139			let settings = ParserSettings { source };1140			let v = parse(&input, &settings).unwrap();1141			let v = format!("{v:#?}");1142			assert_snapshot!(v);1143		});1144	}1145}