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

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	if !p.at(SyntaxKind::IDENT) {223		return Err(p.error(format!("expected identifier, got {}", p.current_desc())));224	}225	let text = p.text();226	p.eat_any();227	Ok(IStr::from(text))228}229230fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {231	let t = match p.peek() {232		T![self] => LiteralType::This,233		T![super] => LiteralType::Super,234		T!['$'] => LiteralType::Dollar,235		T![null] => LiteralType::Null,236		T![true] => LiteralType::True,237		T![false] => LiteralType::False,238		_ => return None,239	};240	p.eat_any();241	Some(t)242}243244fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {245	p.eat(T![assert])?;246	let assertion = spanned(p, expr)?;247	let message = if p.try_eat(T![:]) {248		Some(expr(p)?)249	} else {250		None251	};252	Ok(AssertStmt { assertion, message })253}254255fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {256	let v = spanned(p, |p| p.eat(T![if]))?;257	let cond = expr(p)?;258	Ok(IfSpecData { span: v.span, cond })259}260261fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {262	let cond = if_spec_data(p)?;263	p.eat(T![then])?;264	let cond_then = expr(p)?;265	let cond_else = if p.try_eat(T![else]) {266		Some(expr(p)?)267	} else {268		None269	};270	Ok(IfElse {271		cond,272		cond_then,273		cond_else,274	})275}276277fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {278	p.eat(T![:])?;279	let end = if !p.at(T![:]) && !p.at(T![']']) {280		Some(spanned(p, expr)?)281	} else {282		None283	};284	let step = if p.try_eat(T![:]) {285		if p.at(T![']']) {286			None287		} else {288			Some(spanned(p, expr)?)289		}290	} else {291		None292	};293	Ok(SliceDesc { start, end, step })294}295296fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {297	if p.at(SyntaxKind::IDENT) {298		return Ok(Destruct::Full(spanned(p, ident)?));299	}300	#[cfg(not(feature = "exp-destruct"))]301	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));302	#[cfg(feature = "exp-destruct")]303	{304		if p.try_eat(T![?]) {305			return Ok(Destruct::Skip);306		}307		if p.at(T!['[']) {308			return destruct_array(p);309		}310		if p.at(T!['{']) {311			return destruct_object(p);312		}313		Err(p.error(format!(314			"expected destructure pattern, got {}",315			p.current_desc()316		)))317	}318}319320#[cfg(feature = "exp-destruct")]321fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {322	p.eat(T![...])?;323	if p.at(SyntaxKind::IDENT) {324		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))325	} else {326		Ok(jrsonnet_ir::DestructRest::Drop)327	}328}329330#[cfg(feature = "exp-destruct")]331fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {332	p.eat(T!['['])?;333	let mut start = Vec::new();334	let mut rest = None;335	let mut end = Vec::new();336	if !p.at(T![']']) {337		loop {338			if p.at(T![...]) {339				rest = Some(destruct_rest(p)?);340				if p.try_eat(T![,]) {341					if !p.at(T![']']) {342						loop {343							end.push(destruct(p)?);344							if !p.try_eat(T![,]) {345								break;346							}347							if p.at(T![']']) {348								break;349							}350						}351					}352				}353				break;354			}355			start.push(destruct(p)?);356			if !p.try_eat(T![,]) {357				break;358			}359			if p.at(T![']']) {360				break;361			}362		}363	}364	p.eat(T![']'])?;365	Ok(Destruct::Array { start, rest, end })366}367368#[cfg(feature = "exp-destruct")]369fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {370	p.eat(T!['{'])?;371	let mut fields = Vec::new();372	let mut rest = None;373	if !p.at(T!['}']) {374		loop {375			if p.at(T![...]) {376				rest = Some(destruct_rest(p)?);377				p.try_eat(T![,]);378				break;379			}380			let name = ident(p)?;381			let into = if p.try_eat(T![:]) {382				Some(destruct(p)?)383			} else {384				None385			};386			let default = if p.try_eat(T![=]) {387				Some(spanned(p, expr)?)388			} else {389				None390			};391			fields.push((name, into, default));392			if !p.try_eat(T![,]) {393				break;394			}395			if p.at(T!['}']) {396				break;397			}398		}399	}400	p.eat(T!['}'])?;401	Ok(Destruct::Object { fields, rest })402}403404fn params(p: &mut Parser<'_>) -> Result<ExprParams> {405	if p.at(T![')']) {406		return Ok(ExprParams::new(Vec::new()));407	}408	let mut result = Vec::new();409	loop {410		let d = destruct(p)?;411		let default = if p.try_eat(T![=]) {412			Some(expr(p)?)413		} else {414			None415		};416		result.push(ExprParam {417			destruct: d,418			default,419		});420		if !p.try_eat(T![,]) {421			break;422		}423		if p.at(T![')']) {424			break;425		}426	}427	Ok(ExprParams::new(result))428}429430fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {431	if p.at(T![')']) {432		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));433	}434	let mut unnamed = Vec::new();435	let mut names = Vec::new();436	let mut values = Vec::new();437	let mut named_started = false;438	loop {439		let is_named = p.at(SyntaxKind::IDENT) && {440			let next_offset = p.offset + 1;441			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]442		};443		if is_named {444			let name: IStr = ident(p)?;445			p.eat(T![=])?;446447			names.push(name);448			values.push(expr(p)?);449			named_started = true;450		} else {451			if named_started {452				return Err(p.error("positional argument after named argument".into()));453			}454			unnamed.push(expr(p)?);455		}456		if !p.try_eat(T![,]) {457			break;458		}459		if p.at(T![')']) {460			break;461		}462	}463	Ok(ArgsDesc::new(unnamed, names, values))464}465466fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {467	#[cfg(feature = "exp-destruct")]468	{469		if !p.at(SyntaxKind::IDENT) {470			let d = destruct(p)?;471			p.eat(T![=])?;472			return Ok(BindSpec::Field {473				into: d,474				value: expr(p)?,475			});476		}477	}478	let name_spanned = spanned(p, ident)?;479	if p.try_eat(T!['(']) {480		let ps = params(p)?;481		p.eat(T![')'])?;482		p.eat(T![=])?;483		Ok(BindSpec::Function {484			name: name_spanned.value,485			params: ps,486			value: expr(p)?,487		})488	} else {489		p.eat(T![=])?;490		Ok(BindSpec::Field {491			into: Destruct::Full(name_spanned),492			value: expr(p)?,493		})494	}495}496497fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {498	p.eat(T![:])?;499	if p.try_eat(T![:]) {500		if p.try_eat(T![:]) {501			Ok(Visibility::Unhide)502		} else {503			Ok(Visibility::Hidden)504		}505	} else {506		Ok(Visibility::Normal)507	}508}509510fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {511	if p.at(SyntaxKind::IDENT) {512		Ok(FieldName::Fixed(ident(p)?))513	} else if is_string_token(p.peek()) {514		Ok(FieldName::Fixed(parse_string_content(p)?))515	} else if p.at(T!['[']) {516		p.eat(T!['['])?;517		let e = expr(p)?;518		p.eat(T![']'])?;519		Ok(FieldName::Dyn(e))520	} else {521		Err(p.error(format!("expected field name, got {}", p.current_desc())))522	}523}524525fn field(p: &mut Parser<'_>) -> Result<FieldMember> {526	let name = spanned(p, field_name)?;527528	if p.at(T!['(']) {529		p.eat(T!['('])?;530		let ps = params(p)?;531		p.eat(T![')'])?;532		let vis = visibility(p)?;533		Ok(FieldMember {534			name,535			plus: false,536			params: Some(ps),537			visibility: vis,538			value: expr(p)?,539		})540	} else {541		let plus = p.try_eat(T![+]);542		let vis = visibility(p)?;543		Ok(FieldMember {544			name,545			plus,546			params: None,547			visibility: vis,548			value: expr(p)?,549		})550	}551}552553fn member(p: &mut Parser<'_>) -> Result<Member> {554	if p.at(T![local]) {555		p.eat(T![local])?;556		Ok(Member::BindStmt(bind(p)?))557	} else if p.at(T![assert]) {558		Ok(Member::AssertStmt(assert_stmt(p)?))559	} else {560		Ok(Member::Field(field(p)?))561	}562}563564fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {565	p.eat(T![for])?;566	let d = destruct(p)?;567	p.eat(T![in])?;568	let over = expr(p)?;569	Ok(ForSpecData { destruct: d, over })570}571572fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {573	let mut specs = Vec::new();574	specs.push(CompSpec::ForSpec(for_spec(p)?));575	loop {576		if p.at(T![for]) {577			specs.push(CompSpec::ForSpec(for_spec(p)?));578		} else if p.at(T![if]) {579			let isd = if_spec_data(p)?;580			specs.push(CompSpec::IfSpec(isd));581		} else {582			break;583		}584	}585	Ok(specs)586}587588fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {589	if p.at(T!['}']) {590		return Ok(ObjBody::MemberList(ObjMembers {591			locals: Vec::new(),592			asserts: Vec::new(),593			fields: Vec::new(),594		}));595	}596597	let mut members = Vec::new();598	loop {599		members.push(member(p)?);600		if !p.try_eat(T![,]) {601			break;602		}603		if p.at(T!['}']) || p.at(T![for]) {604			break;605		}606	}607608	if p.at(T![for]) {609		let specs = compspecs(p)?;610		let mut locals = Vec::new();611		let mut field_member = None;612		for m in members {613			match m {614				Member::Field(f) => {615					if field_member.is_some() {616						return Err(617							p.error("object comprehension can only contain one field".into())618						);619					}620					field_member = Some(f);621				}622				Member::BindStmt(b) => locals.push(b),623				Member::AssertStmt(_) => {624					return Err(p.error("asserts are unsupported in object comprehension".into()));625				}626			}627		}628		Ok(ObjBody::ObjComp(ObjComp {629			locals,630			field: Box::new(631				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,632			),633			compspecs: specs,634		}))635	} else {636		let mut locals = Vec::new();637		let mut asserts = Vec::new();638		let mut fields = Vec::new();639		for m in members {640			match m {641				Member::Field(f) => fields.push(f),642				Member::BindStmt(b) => locals.push(b),643				Member::AssertStmt(a) => asserts.push(a),644			}645		}646		Ok(ObjBody::MemberList(ObjMembers {647			locals,648			asserts,649			fields,650		}))651	}652}653654#[allow(clippy::too_many_lines)]655fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {656	if let Some(lit) = literal(p) {657		return Ok(Expr::Literal(lit));658	}659660	match p.peek() {661		SyntaxKind::STRING_DOUBLE662		| SyntaxKind::STRING_SINGLE663		| SyntaxKind::STRING_DOUBLE_VERBATIM664		| SyntaxKind::STRING_SINGLE_VERBATIM665		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),666667		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),668669		T!['('] => {670			p.eat(T!['('])?;671			let e = expr(p)?;672			p.eat(T![')'])?;673			Ok(e)674		}675676		T!['['] => {677			p.eat(T!['['])?;678			if p.at(T![']']) {679				p.eat(T![']'])?;680				return Ok(Expr::Arr(Vec::new()));681			}682			let first = expr(p)?;683			if p.at(T![for]) {684				let specs = compspecs(p)?;685				p.eat(T![']'])?;686				Ok(Expr::ArrComp(Box::new(first), specs))687			} else if p.at(T![,]) && {688				let next = p.offset + 1;689				next < p.lexemes.len() && p.lexemes[next].kind == T![for]690			} {691				p.eat(T![,])?;692				let specs = compspecs(p)?;693				p.eat(T![']'])?;694				Ok(Expr::ArrComp(Box::new(first), specs))695			} else {696				let mut elems = vec![first];697				while p.try_eat(T![,]) {698					if p.at(T![']']) {699						break;700					}701					elems.push(expr(p)?);702				}703				p.eat(T![']'])?;704				Ok(Expr::Arr(elems))705			}706		}707708		T!['{'] => {709			p.eat(T!['{'])?;710			let body = objinside(p)?;711			p.eat(T!['}'])?;712			Ok(Expr::Obj(body))713		}714715		T![local] => {716			p.eat(T![local])?;717			let mut binds = Vec::new();718			loop {719				if p.at(T![;]) {720					break;721				}722				binds.push(bind(p)?);723				if !p.try_eat(T![,]) {724					break;725				}726			}727			p.eat(T![;])?;728			let body = expr(p)?;729			Ok(Expr::LocalExpr(binds, Box::new(body)))730		}731732		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),733734		T![function] => {735			p.eat(T![function])?;736			p.eat(T!['('])?;737			let ps = params(p)?;738			p.eat(T![')'])?;739			let body = expr(p)?;740			Ok(Expr::Function(ps, Box::new(body)))741		}742743		T![assert] => {744			let a = assert_stmt(p)?;745			p.eat(T![;])?;746			let rest = expr(p)?;747			Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))748		}749750		T![error] => {751			let span = spanned(p, |p| p.eat(T![error]))?;752			let e = expr(p)?;753			Ok(Expr::ErrorStmt(span.span, Box::new(e)))754		}755756		T![importstr] => {757			let kind = spanned(p, |p| {758				p.eat(T![importstr])?;759				Ok(ImportKind::Str)760			})?;761			let path = expr(p)?;762			Ok(Expr::Import(kind, Box::new(path)))763		}764765		T![importbin] => {766			let kind = spanned(p, |p| {767				p.eat(T![importbin])?;768				Ok(ImportKind::Bin)769			})?;770			let path = expr(p)?;771			Ok(Expr::Import(kind, Box::new(path)))772		}773774		T![import] => {775			let kind = spanned(p, |p| {776				p.eat(T![import])?;777				Ok(ImportKind::Normal)778			})?;779			let path = expr(p)?;780			Ok(Expr::Import(kind, Box::new(path)))781		}782783		SyntaxKind::IDENT => {784			let n = spanned(p, |p| {785				let s: IStr = p.text().into();786				p.eat_any();787				Ok(s)788			})?;789			Ok(Expr::Var(n))790		}791792		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),793	}794}795796fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {797	if parts.is_empty() {798		return;799	}800	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));801	*e = Expr::Index {802		indexable: Box::new(old),803		parts: std::mem::take(parts),804	};805}806807fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {808	let mut e = expr_basic(p)?;809	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])810	// into a single Expr::Index. This is critical for null-coalesce semantics:811	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.812	let mut parts: Vec<IndexPart> = Vec::new();813814	loop {815		#[cfg(feature = "exp-null-coaelse")]816		if p.at(T![?]) {817			p.eat_any();818			if p.try_eat(T![.]) {819				if p.at(T!['[']) {820					// ?.[expr]821					p.eat(T!['['])?;822					let idx = spanned(p, expr)?;823					p.eat(T![']'])?;824					parts.push(IndexPart {825						span: idx.span,826						value: idx.value,827						null_coaelse: true,828					});829				} else {830					// ?.field831					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;832					parts.push(IndexPart {833						span: id_spanned.span,834						value: id_spanned.value,835						null_coaelse: true,836					});837				}838			} else {839				return Err(p.error("expected '.' after '?'".into()));840			}841			continue;842		}843844		if p.at(T![.]) {845			p.eat(T![.])?;846			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;847			parts.push(IndexPart {848				span: id_spanned.span,849				value: id_spanned.value,850				#[cfg(feature = "exp-null-coaelse")]851				null_coaelse: false,852			});853		} else if p.at(T!['[']) {854			p.eat(T!['['])?;855856			if p.at(T![:]) {857				// Slice: flush index parts first, then handle slice858				flush_index_parts(&mut e, &mut parts);859				let slice = slice_desc(p, None)?;860				p.eat(T![']'])?;861				e = Expr::Slice(Box::new(Slice { value: e, slice }));862			} else {863				let idx = spanned(p, expr)?;864				if p.at(T![:]) {865					// Slice with start: flush index parts first866					flush_index_parts(&mut e, &mut parts);867					let slice = slice_desc(p, Some(idx))?;868					p.eat(T![']'])?;869					e = Expr::Slice(Box::new(Slice { value: e, slice }));870				} else {871					// Bracket index: add to parts872					p.eat(T![']'])?;873					parts.push(IndexPart {874						span: idx.span,875						value: idx.value,876						#[cfg(feature = "exp-null-coaelse")]877						null_coaelse: false,878					});879				}880			}881		} else if p.at(T!['(']) {882			flush_index_parts(&mut e, &mut parts);883			let args_spanned = spanned(p, |p| {884				p.eat(T!['('])?;885				let a = args(p)?;886				p.eat(T![')'])?;887				Ok(a)888			})?;889			let tailstrict = p.try_eat(T![tailstrict]);890			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);891		} else if p.at(T!['{']) {892			flush_index_parts(&mut e, &mut parts);893			p.eat(T!['{'])?;894			let body = objinside(p)?;895			p.eat(T!['}'])?;896			e = Expr::ObjExtend(Box::new(e), body);897		} else {898			break;899		}900	}901902	flush_index_parts(&mut e, &mut parts);903	Ok(e)904}905906fn prefix_binding_power(op: UnaryOpType) -> u8 {907	match op {908		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,909	}910}911912fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {913	match op {914		BinaryOpType::Or => (2, 3),915		#[cfg(feature = "exp-null-coaelse")]916		BinaryOpType::NullCoaelse => (2, 3),917		BinaryOpType::And => (4, 5),918		BinaryOpType::BitOr => (6, 7),919		BinaryOpType::BitXor => (8, 9),920		BinaryOpType::BitAnd => (10, 11),921		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),922		BinaryOpType::Lt923		| BinaryOpType::Gt924		| BinaryOpType::Lte925		| BinaryOpType::Gte926		| BinaryOpType::In => (14, 15),927		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),928		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),929		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),930	}931}932933fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {934	match kind {935		T![+] => Some(UnaryOpType::Plus),936		T![-] => Some(UnaryOpType::Minus),937		T![!] => Some(UnaryOpType::Not),938		T![~] => Some(UnaryOpType::BitNot),939		_ => None,940	}941}942943fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {944	match p.peek() {945		T![||] => Some(BinaryOpType::Or),946		T![&&] => Some(BinaryOpType::And),947		T![|] => Some(BinaryOpType::BitOr),948		T![^] => Some(BinaryOpType::BitXor),949		T![&] => Some(BinaryOpType::BitAnd),950		T![==] => Some(BinaryOpType::Eq),951		T![!=] => Some(BinaryOpType::Neq),952		T![<] => Some(BinaryOpType::Lt),953		T![>] => Some(BinaryOpType::Gt),954		T![<=] => Some(BinaryOpType::Lte),955		T![>=] => Some(BinaryOpType::Gte),956		T![<<] => Some(BinaryOpType::Lhs),957		T![>>] => Some(BinaryOpType::Rhs),958		T![+] => Some(BinaryOpType::Add),959		T![-] => Some(BinaryOpType::Sub),960		T![*] => Some(BinaryOpType::Mul),961		T![/] => Some(BinaryOpType::Div),962		T![%] => Some(BinaryOpType::Mod),963		T![in] => Some(BinaryOpType::In),964		#[cfg(feature = "exp-null-coaelse")]965		T![??] => Some(BinaryOpType::NullCoaelse),966		_ => None,967	}968}969970fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {971	let mut lhs = if let Some(op) = unary_op(p.peek()) {972		p.eat_any();973		let rbp = prefix_binding_power(op);974		let rhs = expr_bp(p, rbp)?;975		Expr::UnaryOp(op, Box::new(rhs))976	} else {977		expr_suffix(p)?978	};979980	loop {981		if p.at_eof() {982			break;983		}984985		let Some(op) = binary_op(p) else {986			break;987		};988989		let (lbp, rbp) = infix_binding_power(op);990		if lbp < min_bp {991			break;992		}993994		p.eat_any();995		let rhs = expr_bp(p, rbp)?;996		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));997	}998999	Ok(lhs)1000}10011002fn expr(p: &mut Parser<'_>) -> Result<Expr> {1003	expr_bp(p, 0)1004}10051006pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1007	let mut p = Parser::new(str, settings.source.clone());1008	for lexeme in &p.lexemes {1009		if let Some(desc) = lexeme.kind.error_description() {1010			return Err(ParseError {1011				message: desc.to_owned(),1012				location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1013			});1014		}1015	}1016	let e = expr(&mut p)?;1017	if !p.at_eof() {1018		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1019	}1020	Ok(e)1021}10221023pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1024	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10251026	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1027}10281029#[cfg(test)]1030mod tests {1031	use std::fs;10321033	use insta::{assert_snapshot, glob};1034	use jrsonnet_ir::{IStr, Source};10351036	use super::*;10371038	fn parse_str(input: &str) -> Expr {1039		let source = Source::new_virtual("<test>".into(), input.into());1040		let settings = ParserSettings { source };1041		parse(input, &settings).unwrap()1042	}10431044	#[test]1045	#[cfg(not(feature = "exp-null-coaelse"))]1046	fn basic_test() {1047		let v = parse_str("assert true[false] : false ; true");1048		assert_snapshot!(format!("{v:#?}"));1049	}10501051	#[test]1052	fn literals() {1053		let v = parse_str("[null, true, false, self, super, $]");1054		assert_snapshot!(format!("{v:#?}"));1055	}10561057	#[test]1058	fn basic_math() {1059		let v = parse_str("2+2*2");1060		assert_snapshot!(format!("{v:#?}"));1061	}10621063	#[test]1064	fn underscore_numbers() {1065		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1066		assert_snapshot!(format!("{v:#?}"));1067	}10681069	#[test]1070	fn strings() {1071		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1072		assert_snapshot!(format!("{v:#?}"));1073	}10741075	#[test]1076	fn object() {1077		let v = parse_str("{a: 1, b:: 2, c::: 3}");1078		assert_snapshot!(format!("{v:#?}"));1079	}10801081	#[test]1082	fn function_and_call() {1083		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1084		assert_snapshot!(format!("{v:#?}"));1085	}10861087	#[test]1088	fn if_then_else() {1089		let v = parse_str("if true then 1 else 2");1090		assert_snapshot!(format!("{v:#?}"));1091	}10921093	#[test]1094	fn imports() {1095		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1096		assert_snapshot!(format!("{v:#?}"));1097	}10981099	#[test]1100	fn array_comp() {1101		let v = parse_str("[x for x in arr]");1102		assert_snapshot!(format!("{v:#?}"));1103	}11041105	#[test]1106	#[cfg(not(feature = "exp-null-coaelse"))]1107	fn index_and_suffix() {1108		let v = parse_str("std.test(2).field[0]");1109		assert_snapshot!(format!("{v:#?}"));1110	}11111112	#[test]1113	fn obj_extend() {1114		let v = parse_str("{} { x: 1 }");1115		assert_snapshot!(format!("{v:#?}"));1116	}11171118	#[test]1119	fn unary_ops() {1120		let v = parse_str("!a && !b");1121		assert_snapshot!(format!("{v:#?}"));1122	}11231124	#[test]1125	fn error_expr() {1126		let v = parse_str("error \"bad\"");1127		assert_snapshot!(format!("{v:#?}"));1128	}11291130	#[test]1131	fn slice() {1132		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1133		assert_snapshot!(format!("{v:#?}"));1134	}11351136	#[test]1137	#[cfg(not(feature = "exp-null-coaelse"))]1138	fn peg_snapshots() {1139		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1140			let input = fs::read_to_string(path).expect("read test file");1141			let source = Source::new_virtual("<test>".into(), IStr::empty());1142			let settings = ParserSettings { source };1143			let v = parse(&input, &settings).unwrap();1144			let v = format!("{v:#?}");1145			assert_snapshot!(v);1146		});1147	}1148}