git.delta.rocks / jrsonnet / refs/commits / 36af281ff0ca

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	#[allow(dead_code)]70	fn nth(&self, n: usize) -> SyntaxKind {71		self.lexemes72			.get(self.offset + n)73			.map_or(SyntaxKind::EOF, |l| l.kind)74	}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		if self.offset == self.lexemes.len() {134			let pos = self.lexemes.last().map_or(0, |v| v.range.1);135			return ParseError {136				location: Span(self.source.clone(), pos, pos),137				message,138			};139		}140		let LexSpan(start, end) = self.lexemes[self.offset].range;141		ParseError {142			location: Span(self.source.clone(), start, end),143			message,144		}145	}146}147148fn spanned<T: Acyclic>(149	p: &mut Parser<'_>,150	cb: impl FnOnce(&mut Parser<'_>) -> Result<T>,151) -> Result<Spanned<T>> {152	let start = p.span_start();153	let v = cb(p)?;154	let end = p.span_end();155	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))156}157158fn parse_string_content(p: &mut Parser<'_>) -> Result<IStr> {159	let kind = p.peek();160	let text = p.text();161	let s = match kind {162		SyntaxKind::STRING_DOUBLE => {163			let inner = &text[1..text.len() - 1];164			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?165		}166		SyntaxKind::STRING_SINGLE => {167			let inner = &text[1..text.len() - 1];168			unescape::unescape(inner).ok_or_else(|| p.error("invalid string escape".into()))?169		}170		SyntaxKind::STRING_DOUBLE_VERBATIM => {171			let inner = &text[2..text.len() - 1];172			inner.replace("\"\"", "\"")173		}174		SyntaxKind::STRING_SINGLE_VERBATIM => {175			let inner = &text[2..text.len() - 1];176			inner.replace("''", "'")177		}178		SyntaxKind::STRING_BLOCK => {179			let inner = &text[3..];180			let collected = collect_lexed_str_block(inner)181				.map_err(|_| p.error("invalid string block".into()))?;182			let mut result = String::new();183			for (i, line) in collected.lines.iter().enumerate() {184				if i > 0 {185					result.push('\n');186				}187				result.push_str(line);188			}189			if !collected.truncate {190				result.push('\n');191			}192			result193		}194		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),195	};196	p.eat_any();197	Ok(s.into())198}199200fn is_string_token(kind: SyntaxKind) -> bool {201	matches!(202		kind,203		SyntaxKind::STRING_DOUBLE204			| SyntaxKind::STRING_SINGLE205			| SyntaxKind::STRING_DOUBLE_VERBATIM206			| SyntaxKind::STRING_SINGLE_VERBATIM207			| SyntaxKind::STRING_BLOCK208	)209}210211fn parse_number(p: &mut Parser<'_>) -> Result<NumValue> {212	let text = p.text();213	let n: f64 = text214		.replace('_', "")215		.parse()216		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;217218	let v = match NumValue::try_from(n) {219		Ok(v) => v,220		Err(e) => return Err(p.error(format!("invalid number value: {e}"))),221	};222223	p.eat_any();224225	Ok(v)226}227228fn ident(p: &mut Parser<'_>) -> Result<IStr> {229	if !p.at(SyntaxKind::IDENT) {230		return Err(p.error(format!("expected identifier, got {}", p.current_desc())));231	}232	let text = p.text();233	p.eat_any();234	Ok(IStr::from(text))235}236237fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {238	let t = match p.peek() {239		T![self] => LiteralType::This,240		T![super] => LiteralType::Super,241		T!['$'] => LiteralType::Dollar,242		T![null] => LiteralType::Null,243		T![true] => LiteralType::True,244		T![false] => LiteralType::False,245		_ => return None,246	};247	p.eat_any();248	Some(t)249}250251fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {252	p.eat(T![assert])?;253	let assertion = spanned(p, expr)?;254	let message = if p.try_eat(T![:]) {255		Some(expr(p)?)256	} else {257		None258	};259	Ok(AssertStmt { assertion, message })260}261262fn if_spec_data(p: &mut Parser<'_>) -> Result<IfSpecData> {263	let v = spanned(p, |p| p.eat(T![if]))?;264	let cond = expr(p)?;265	Ok(IfSpecData { span: v.span, cond })266}267268fn if_else(p: &mut Parser<'_>) -> Result<IfElse> {269	let cond = if_spec_data(p)?;270	p.eat(T![then])?;271	let cond_then = expr(p)?;272	let cond_else = if p.try_eat(T![else]) {273		Some(expr(p)?)274	} else {275		None276	};277	Ok(IfElse {278		cond,279		cond_then,280		cond_else,281	})282}283284fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> Result<SliceDesc> {285	p.eat(T![:])?;286	let end = if !p.at(T![:]) && !p.at(T![']']) {287		Some(spanned(p, expr)?)288	} else {289		None290	};291	let step = if p.try_eat(T![:]) {292		if p.at(T![']']) {293			None294		} else {295			Some(spanned(p, expr)?)296		}297	} else {298		None299	};300	Ok(SliceDesc { start, end, step })301}302303fn destruct(p: &mut Parser<'_>) -> Result<Destruct> {304	if p.at(SyntaxKind::IDENT) {305		return Ok(Destruct::Full(spanned(p, ident)?));306	}307	#[cfg(not(feature = "exp-destruct"))]308	return Err(p.error(format!("expected identifier, got {}", p.current_desc())));309	#[cfg(feature = "exp-destruct")]310	{311		if p.try_eat(T![?]) {312			return Ok(Destruct::Skip);313		}314		if p.at(T!['[']) {315			return destruct_array(p);316		}317		if p.at(T!['{']) {318			return destruct_object(p);319		}320		Err(p.error(format!(321			"expected destructure pattern, got {}",322			p.current_desc()323		)))324	}325}326327#[cfg(feature = "exp-destruct")]328fn destruct_rest(p: &mut Parser<'_>) -> Result<jrsonnet_ir::DestructRest> {329	p.eat(T![...])?;330	if p.at(SyntaxKind::IDENT) {331		Ok(jrsonnet_ir::DestructRest::Keep(ident(p)?))332	} else {333		Ok(jrsonnet_ir::DestructRest::Drop)334	}335}336337#[cfg(feature = "exp-destruct")]338fn destruct_array(p: &mut Parser<'_>) -> Result<Destruct> {339	p.eat(T!['['])?;340	let mut start = Vec::new();341	let mut rest = None;342	let mut end = Vec::new();343	if !p.at(T![']']) {344		loop {345			if p.at(T![...]) {346				rest = Some(destruct_rest(p)?);347				if p.try_eat(T![,]) {348					if !p.at(T![']']) {349						loop {350							end.push(destruct(p)?);351							if !p.try_eat(T![,]) {352								break;353							}354							if p.at(T![']']) {355								break;356							}357						}358					}359				}360				break;361			}362			start.push(destruct(p)?);363			if !p.try_eat(T![,]) {364				break;365			}366			if p.at(T![']']) {367				break;368			}369		}370	}371	p.eat(T![']'])?;372	Ok(Destruct::Array { start, rest, end })373}374375#[cfg(feature = "exp-destruct")]376fn destruct_object(p: &mut Parser<'_>) -> Result<Destruct> {377	p.eat(T!['{'])?;378	let mut fields = Vec::new();379	let mut rest = None;380	if !p.at(T!['}']) {381		loop {382			if p.at(T![...]) {383				rest = Some(destruct_rest(p)?);384				p.try_eat(T![,]);385				break;386			}387			let name = ident(p)?;388			let into = if p.try_eat(T![:]) {389				Some(destruct(p)?)390			} else {391				None392			};393			let default = if p.try_eat(T![=]) {394				Some(spanned(p, expr)?)395			} else {396				None397			};398			fields.push((name, into, default));399			if !p.try_eat(T![,]) {400				break;401			}402			if p.at(T!['}']) {403				break;404			}405		}406	}407	p.eat(T!['}'])?;408	Ok(Destruct::Object { fields, rest })409}410411fn params(p: &mut Parser<'_>) -> Result<ExprParams> {412	if p.at(T![')']) {413		return Ok(ExprParams::new(Vec::new()));414	}415	let mut result = Vec::new();416	loop {417		let d = destruct(p)?;418		let default = if p.try_eat(T![=]) {419			Some(expr(p)?)420		} else {421			None422		};423		result.push(ExprParam {424			destruct: d,425			default,426		});427		if !p.try_eat(T![,]) {428			break;429		}430		if p.at(T![')']) {431			break;432		}433	}434	Ok(ExprParams::new(result))435}436437fn args(p: &mut Parser<'_>) -> Result<ArgsDesc> {438	if p.at(T![')']) {439		return Ok(ArgsDesc::new(Vec::new(), Vec::new(), Vec::new()));440	}441	let mut unnamed = Vec::new();442	let mut names = Vec::new();443	let mut values = Vec::new();444	let mut named_started = false;445	loop {446		let is_named = p.at(SyntaxKind::IDENT) && {447			let next_offset = p.offset + 1;448			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]449		};450		if is_named {451			let name: IStr = ident(p)?;452			p.eat(T![=])?;453454			names.push(name);455			values.push(expr(p)?);456			named_started = true;457		} else {458			if named_started {459				return Err(p.error("positional argument after named argument".into()));460			}461			unnamed.push(expr(p)?);462		}463		if !p.try_eat(T![,]) {464			break;465		}466		if p.at(T![')']) {467			break;468		}469	}470	Ok(ArgsDesc::new(unnamed, names, values))471}472473fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {474	#[cfg(feature = "exp-destruct")]475	{476		if !p.at(SyntaxKind::IDENT) {477			let d = destruct(p)?;478			p.eat(T![=])?;479			return Ok(BindSpec::Field {480				into: d,481				value: expr(p)?,482			});483		}484	}485	let name_spanned = spanned(p, ident)?;486	if p.try_eat(T!['(']) {487		let ps = params(p)?;488		p.eat(T![')'])?;489		p.eat(T![=])?;490		Ok(BindSpec::Function {491			name: name_spanned.value,492			params: ps,493			value: expr(p)?,494		})495	} else {496		p.eat(T![=])?;497		Ok(BindSpec::Field {498			into: Destruct::Full(name_spanned),499			value: expr(p)?,500		})501	}502}503504fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {505	p.eat(T![:])?;506	if p.try_eat(T![:]) {507		if p.try_eat(T![:]) {508			Ok(Visibility::Unhide)509		} else {510			Ok(Visibility::Hidden)511		}512	} else {513		Ok(Visibility::Normal)514	}515}516517fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {518	if p.at(SyntaxKind::IDENT) {519		Ok(FieldName::Fixed(ident(p)?))520	} else if is_string_token(p.peek()) {521		Ok(FieldName::Fixed(parse_string_content(p)?))522	} else if p.at(T!['[']) {523		p.eat(T!['['])?;524		let e = expr(p)?;525		p.eat(T![']'])?;526		Ok(FieldName::Dyn(e))527	} else {528		Err(p.error(format!("expected field name, got {}", p.current_desc())))529	}530}531532fn field(p: &mut Parser<'_>) -> Result<FieldMember> {533	let name = spanned(p, field_name)?;534535	if p.at(T!['(']) {536		p.eat(T!['('])?;537		let ps = params(p)?;538		p.eat(T![')'])?;539		let vis = visibility(p)?;540		Ok(FieldMember {541			name,542			plus: false,543			params: Some(ps),544			visibility: vis,545			value: expr(p)?,546		})547	} else {548		let plus = p.try_eat(T![+]);549		let vis = visibility(p)?;550		Ok(FieldMember {551			name,552			plus,553			params: None,554			visibility: vis,555			value: expr(p)?,556		})557	}558}559560fn member(p: &mut Parser<'_>) -> Result<Member> {561	if p.at(T![local]) {562		p.eat(T![local])?;563		Ok(Member::BindStmt(bind(p)?))564	} else if p.at(T![assert]) {565		Ok(Member::AssertStmt(assert_stmt(p)?))566	} else {567		Ok(Member::Field(field(p)?))568	}569}570571fn for_spec(p: &mut Parser<'_>) -> Result<CompSpec> {572	p.eat(T![for])?;573	#[cfg(feature = "exp-object-iteration")]574	if p.at(T!['[']) && p.nth(1) == SyntaxKind::IDENT && p.nth(2) == T![']'] && p.nth(3) == T![:] {575		p.eat(T!['['])?;576		let key = ident(p)?;577		p.eat(T![']'])?;578		let visibility = visibility(p)?;579		let value = destruct(p)?;580		p.eat(T![in])?;581		let over = expr(p)?;582		return Ok(CompSpec::ForObjSpec(jrsonnet_ir::ForObjSpecData {583			key,584			visibility,585			value,586			over,587		}));588	}589	let d = destruct(p)?;590	p.eat(T![in])?;591	let over = expr(p)?;592	Ok(CompSpec::ForSpec(ForSpecData { destruct: d, over }))593}594595fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {596	let mut specs = Vec::new();597	specs.push(for_spec(p)?);598	loop {599		if p.at(T![for]) {600			specs.push(for_spec(p)?);601		} else if p.at(T![if]) {602			let isd = if_spec_data(p)?;603			specs.push(CompSpec::IfSpec(isd));604		} else {605			break;606		}607	}608	Ok(specs)609}610611fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {612	if p.at(T!['}']) {613		return Ok(ObjBody::MemberList(ObjMembers {614			locals: Vec::new(),615			asserts: Vec::new(),616			fields: Vec::new(),617		}));618	}619620	let mut members = Vec::new();621	loop {622		members.push(member(p)?);623		if !p.try_eat(T![,]) {624			break;625		}626		if p.at(T!['}']) || p.at(T![for]) {627			break;628		}629	}630631	if p.at(T![for]) {632		let specs = compspecs(p)?;633		let mut locals = Vec::new();634		let mut field_member = None;635		for m in members {636			match m {637				Member::Field(f) => {638					if field_member.is_some() {639						return Err(640							p.error("object comprehension can only contain one field".into())641						);642					}643					field_member = Some(f);644				}645				Member::BindStmt(b) => locals.push(b),646				Member::AssertStmt(_) => {647					return Err(p.error("asserts are unsupported in object comprehension".into()));648				}649			}650		}651		Ok(ObjBody::ObjComp(ObjComp {652			locals,653			field: Box::new(654				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,655			),656			compspecs: specs,657		}))658	} else {659		let mut locals = Vec::new();660		let mut asserts = Vec::new();661		let mut fields = Vec::new();662		for m in members {663			match m {664				Member::Field(f) => fields.push(f),665				Member::BindStmt(b) => locals.push(b),666				Member::AssertStmt(a) => asserts.push(a),667			}668		}669		Ok(ObjBody::MemberList(ObjMembers {670			locals,671			asserts,672			fields,673		}))674	}675}676677#[allow(clippy::too_many_lines)]678fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {679	if let Some(lit) = literal(p) {680		return Ok(Expr::Literal(lit));681	}682683	match p.peek() {684		SyntaxKind::STRING_DOUBLE685		| SyntaxKind::STRING_SINGLE686		| SyntaxKind::STRING_DOUBLE_VERBATIM687		| SyntaxKind::STRING_SINGLE_VERBATIM688		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),689690		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),691692		T!['('] => {693			p.eat(T!['('])?;694			let e = expr(p)?;695			p.eat(T![')'])?;696			Ok(e)697		}698699		T!['['] => {700			p.eat(T!['['])?;701			if p.at(T![']']) {702				p.eat(T![']'])?;703				return Ok(Expr::Arr(Vec::new()));704			}705			let first = expr(p)?;706			if p.at(T![for]) {707				let specs = compspecs(p)?;708				p.eat(T![']'])?;709				Ok(Expr::ArrComp(Box::new(first), specs))710			} else if p.at(T![,]) && {711				let next = p.offset + 1;712				next < p.lexemes.len() && p.lexemes[next].kind == T![for]713			} {714				p.eat(T![,])?;715				let specs = compspecs(p)?;716				p.eat(T![']'])?;717				Ok(Expr::ArrComp(Box::new(first), specs))718			} else {719				let mut elems = vec![first];720				while p.try_eat(T![,]) {721					if p.at(T![']']) {722						break;723					}724					elems.push(expr(p)?);725				}726				p.eat(T![']'])?;727				Ok(Expr::Arr(elems))728			}729		}730731		T!['{'] => {732			p.eat(T!['{'])?;733			let body = objinside(p)?;734			p.eat(T!['}'])?;735			Ok(Expr::Obj(body))736		}737738		T![local] => {739			p.eat(T![local])?;740			let mut binds = Vec::new();741			loop {742				if p.at(T![;]) {743					break;744				}745				binds.push(bind(p)?);746				if !p.try_eat(T![,]) {747					break;748				}749			}750			p.eat(T![;])?;751			let body = expr(p)?;752			Ok(Expr::LocalExpr(binds, Box::new(body)))753		}754755		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),756757		T![function] => {758			p.eat(T![function])?;759			p.eat(T!['('])?;760			let ps = params(p)?;761			p.eat(T![')'])?;762			let body = expr(p)?;763			Ok(Expr::Function(ps, Box::new(body)))764		}765766		T![assert] => {767			let a = assert_stmt(p)?;768			p.eat(T![;])?;769			let rest = expr(p)?;770			Ok(Expr::AssertExpr(Box::new(AssertExpr { assert: a, rest })))771		}772773		T![error] => {774			let span = spanned(p, |p| p.eat(T![error]))?;775			let e = expr(p)?;776			Ok(Expr::ErrorStmt(span.span, Box::new(e)))777		}778779		T![importstr] => {780			let kind = spanned(p, |p| {781				p.eat(T![importstr])?;782				Ok(ImportKind::Str)783			})?;784			let path = expr(p)?;785			Ok(Expr::Import(kind, Box::new(path)))786		}787788		T![importbin] => {789			let kind = spanned(p, |p| {790				p.eat(T![importbin])?;791				Ok(ImportKind::Bin)792			})?;793			let path = expr(p)?;794			Ok(Expr::Import(kind, Box::new(path)))795		}796797		T![import] => {798			let kind = spanned(p, |p| {799				p.eat(T![import])?;800				Ok(ImportKind::Normal)801			})?;802			let path = expr(p)?;803			Ok(Expr::Import(kind, Box::new(path)))804		}805806		SyntaxKind::IDENT => {807			let n = spanned(p, |p| {808				let s: IStr = p.text().into();809				p.eat_any();810				Ok(s)811			})?;812			Ok(Expr::Var(n))813		}814815		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),816	}817}818819fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {820	if parts.is_empty() {821		return;822	}823	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));824	*e = Expr::Index {825		indexable: Box::new(old),826		parts: std::mem::take(parts),827	};828}829830fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {831	let mut e = expr_basic(p)?;832	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])833	// into a single Expr::Index. This is critical for null-coalesce semantics:834	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.835	let mut parts: Vec<IndexPart> = Vec::new();836837	loop {838		#[cfg(feature = "exp-null-coaelse")]839		if p.at(T![?]) {840			p.eat_any();841			if p.try_eat(T![.]) {842				if p.at(T!['[']) {843					// ?.[expr]844					p.eat(T!['['])?;845					let idx = spanned(p, expr)?;846					p.eat(T![']'])?;847					parts.push(IndexPart {848						span: idx.span,849						value: idx.value,850						null_coaelse: true,851					});852				} else {853					// ?.field854					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;855					parts.push(IndexPart {856						span: id_spanned.span,857						value: id_spanned.value,858						null_coaelse: true,859					});860				}861			} else {862				return Err(p.error("expected '.' after '?'".into()));863			}864			continue;865		}866867		if p.at(T![.]) {868			p.eat(T![.])?;869			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;870			parts.push(IndexPart {871				span: id_spanned.span,872				value: id_spanned.value,873				#[cfg(feature = "exp-null-coaelse")]874				null_coaelse: false,875			});876		} else if p.at(T!['[']) {877			p.eat(T!['['])?;878879			if p.at(T![:]) {880				// Slice: flush index parts first, then handle slice881				flush_index_parts(&mut e, &mut parts);882				let slice = slice_desc(p, None)?;883				p.eat(T![']'])?;884				e = Expr::Slice(Box::new(Slice { value: e, slice }));885			} else {886				let idx = spanned(p, expr)?;887				if p.at(T![:]) {888					// Slice with start: flush index parts first889					flush_index_parts(&mut e, &mut parts);890					let slice = slice_desc(p, Some(idx))?;891					p.eat(T![']'])?;892					e = Expr::Slice(Box::new(Slice { value: e, slice }));893				} else {894					// Bracket index: add to parts895					p.eat(T![']'])?;896					parts.push(IndexPart {897						span: idx.span,898						value: idx.value,899						#[cfg(feature = "exp-null-coaelse")]900						null_coaelse: false,901					});902				}903			}904		} else if p.at(T!['(']) {905			flush_index_parts(&mut e, &mut parts);906			let args_spanned = spanned(p, |p| {907				p.eat(T!['('])?;908				let a = args(p)?;909				p.eat(T![')'])?;910				Ok(a)911			})?;912			let tailstrict = p.try_eat(T![tailstrict]);913			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);914		} else if p.at(T!['{']) {915			flush_index_parts(&mut e, &mut parts);916			p.eat(T!['{'])?;917			let body = objinside(p)?;918			p.eat(T!['}'])?;919			e = Expr::ObjExtend(Box::new(e), body);920		} else {921			break;922		}923	}924925	flush_index_parts(&mut e, &mut parts);926	Ok(e)927}928929fn prefix_binding_power(op: UnaryOpType) -> u8 {930	match op {931		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,932	}933}934935fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {936	match op {937		BinaryOpType::Or => (2, 3),938		#[cfg(feature = "exp-null-coaelse")]939		BinaryOpType::NullCoaelse => (2, 3),940		BinaryOpType::And => (4, 5),941		BinaryOpType::BitOr => (6, 7),942		BinaryOpType::BitXor => (8, 9),943		BinaryOpType::BitAnd => (10, 11),944		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),945		BinaryOpType::Lt946		| BinaryOpType::Gt947		| BinaryOpType::Lte948		| BinaryOpType::Gte949		| BinaryOpType::In => (14, 15),950		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),951		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),952		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),953	}954}955956fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {957	match kind {958		T![+] => Some(UnaryOpType::Plus),959		T![-] => Some(UnaryOpType::Minus),960		T![!] => Some(UnaryOpType::Not),961		T![~] => Some(UnaryOpType::BitNot),962		_ => None,963	}964}965966fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {967	match p.peek() {968		T![||] => Some(BinaryOpType::Or),969		T![&&] => Some(BinaryOpType::And),970		T![|] => Some(BinaryOpType::BitOr),971		T![^] => Some(BinaryOpType::BitXor),972		T![&] => Some(BinaryOpType::BitAnd),973		T![==] => Some(BinaryOpType::Eq),974		T![!=] => Some(BinaryOpType::Neq),975		T![<] => Some(BinaryOpType::Lt),976		T![>] => Some(BinaryOpType::Gt),977		T![<=] => Some(BinaryOpType::Lte),978		T![>=] => Some(BinaryOpType::Gte),979		T![<<] => Some(BinaryOpType::Lhs),980		T![>>] => Some(BinaryOpType::Rhs),981		T![+] => Some(BinaryOpType::Add),982		T![-] => Some(BinaryOpType::Sub),983		T![*] => Some(BinaryOpType::Mul),984		T![/] => Some(BinaryOpType::Div),985		T![%] => Some(BinaryOpType::Mod),986		T![in] => Some(BinaryOpType::In),987		#[cfg(feature = "exp-null-coaelse")]988		T![??] => Some(BinaryOpType::NullCoaelse),989		_ => None,990	}991}992993fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {994	let mut lhs = if let Some(op) = unary_op(p.peek()) {995		p.eat_any();996		let rbp = prefix_binding_power(op);997		let rhs = expr_bp(p, rbp)?;998		Expr::UnaryOp(op, Box::new(rhs))999	} else {1000		expr_suffix(p)?1001	};10021003	loop {1004		if p.at_eof() {1005			break;1006		}10071008		let Some(op) = binary_op(p) else {1009			break;1010		};10111012		let (lbp, rbp) = infix_binding_power(op);1013		if lbp < min_bp {1014			break;1015		}10161017		p.eat_any();1018		let rhs = expr_bp(p, rbp)?;1019		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));1020	}10211022	Ok(lhs)1023}10241025fn expr(p: &mut Parser<'_>) -> Result<Expr> {1026	expr_bp(p, 0)1027}10281029pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {1030	let mut p = Parser::new(str, settings.source.clone());1031	for lexeme in &p.lexemes {1032		if let Some(desc) = lexeme.kind.error_description() {1033			return Err(ParseError {1034				message: desc.to_owned(),1035				location: Span(p.source.clone(), lexeme.range.0, lexeme.range.1),1036			});1037		}1038	}1039	let e = expr(&mut p)?;1040	if !p.at_eof() {1041		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1042	}1043	Ok(e)1044}10451046pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1047	let len = u32::try_from(s.len()).expect("code size is limited by 4gb");10481049	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len))1050}10511052#[cfg(test)]1053mod tests {1054	use std::fs;10551056	use insta::{assert_snapshot, glob};1057	use jrsonnet_ir::{IStr, Source};10581059	use super::*;10601061	fn parse_str(input: &str) -> Expr {1062		let source = Source::new_virtual("<test>".into(), input.into());1063		let settings = ParserSettings { source };1064		parse(input, &settings).unwrap()1065	}10661067	#[test]1068	#[cfg(not(feature = "exp-null-coaelse"))]1069	fn basic_test() {1070		let v = parse_str("assert true[false] : false ; true");1071		assert_snapshot!(format!("{v:#?}"));1072	}10731074	#[test]1075	fn literals() {1076		let v = parse_str("[null, true, false, self, super, $]");1077		assert_snapshot!(format!("{v:#?}"));1078	}10791080	#[test]1081	fn basic_math() {1082		let v = parse_str("2+2*2");1083		assert_snapshot!(format!("{v:#?}"));1084	}10851086	#[test]1087	fn underscore_numbers() {1088		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1089		assert_snapshot!(format!("{v:#?}"));1090	}10911092	#[test]1093	fn strings() {1094		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1095		assert_snapshot!(format!("{v:#?}"));1096	}10971098	#[test]1099	fn object() {1100		let v = parse_str("{a: 1, b:: 2, c::: 3}");1101		assert_snapshot!(format!("{v:#?}"));1102	}11031104	#[test]1105	fn function_and_call() {1106		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1107		assert_snapshot!(format!("{v:#?}"));1108	}11091110	#[test]1111	fn if_then_else() {1112		let v = parse_str("if true then 1 else 2");1113		assert_snapshot!(format!("{v:#?}"));1114	}11151116	#[test]1117	fn imports() {1118		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1119		assert_snapshot!(format!("{v:#?}"));1120	}11211122	#[test]1123	fn array_comp() {1124		let v = parse_str("[x for x in arr]");1125		assert_snapshot!(format!("{v:#?}"));1126	}11271128	#[test]1129	#[cfg(not(feature = "exp-null-coaelse"))]1130	fn index_and_suffix() {1131		let v = parse_str("std.test(2).field[0]");1132		assert_snapshot!(format!("{v:#?}"));1133	}11341135	#[test]1136	fn obj_extend() {1137		let v = parse_str("{} { x: 1 }");1138		assert_snapshot!(format!("{v:#?}"));1139	}11401141	#[test]1142	fn unary_ops() {1143		let v = parse_str("!a && !b");1144		assert_snapshot!(format!("{v:#?}"));1145	}11461147	#[test]1148	fn error_expr() {1149		let v = parse_str("error \"bad\"");1150		assert_snapshot!(format!("{v:#?}"));1151	}11521153	#[test]1154	fn slice() {1155		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1156		assert_snapshot!(format!("{v:#?}"));1157	}11581159	#[test]1160	#[cfg(not(feature = "exp-null-coaelse"))]1161	fn peg_snapshots() {1162		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1163			let input = fs::read_to_string(path).expect("read test file");1164			let source = Source::new_virtual("<test>".into(), IStr::empty());1165			let settings = ParserSettings { source };1166			let v = parse(&input, &settings).unwrap();1167			let v = format!("{v:#?}");1168			assert_snapshot!(v);1169		});1170	}1171}