git.delta.rocks / jrsonnet / refs/commits / 1bfba233fc03

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()));420	}421	let mut unnamed = Vec::new();422	let mut named = Vec::new();423	let mut named_started = false;424	loop {425		let is_named = p.at(SyntaxKind::IDENT) && {426			let next_offset = p.offset + 1;427			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=]428		};429		if is_named {430			let name: IStr = ident(p)?;431			p.eat(T![=])?;432			let value = Rc::new(expr(p)?);433			named.push((name, value));434			named_started = true;435		} else {436			if named_started {437				return Err(p.error("positional argument after named argument".into()));438			}439			unnamed.push(Rc::new(expr(p)?));440		}441		if !p.try_eat(T![,]) {442			break;443		}444		if p.at(T![')']) {445			break;446		}447	}448	Ok(ArgsDesc::new(unnamed, named))449}450451fn bind(p: &mut Parser<'_>) -> Result<BindSpec> {452	#[cfg(feature = "exp-destruct")]453	{454		if !p.at(SyntaxKind::IDENT) {455			let d = destruct(p)?;456			p.eat(T![=])?;457			let value = Rc::new(expr(p)?);458			return Ok(BindSpec::Field { into: d, value });459		}460	}461	let name = ident(p)?;462	if p.try_eat(T!['(']) {463		let ps = params(p)?;464		p.eat(T![')'])?;465		p.eat(T![=])?;466		let value = Rc::new(expr(p)?);467		Ok(BindSpec::Function {468			name,469			params: ps,470			value,471		})472	} else {473		p.eat(T![=])?;474		let value = Rc::new(expr(p)?);475		Ok(BindSpec::Field {476			into: Destruct::Full(name),477			value,478		})479	}480}481482fn visibility(p: &mut Parser<'_>) -> Result<Visibility> {483	p.eat(T![:])?;484	if p.try_eat(T![:]) {485		if p.try_eat(T![:]) {486			Ok(Visibility::Unhide)487		} else {488			Ok(Visibility::Hidden)489		}490	} else {491		Ok(Visibility::Normal)492	}493}494495fn field_name(p: &mut Parser<'_>) -> Result<FieldName> {496	if p.at(SyntaxKind::IDENT) {497		Ok(FieldName::Fixed(ident(p)?))498	} else if is_string_token(p.peek()) {499		Ok(FieldName::Fixed(parse_string_content(p)?))500	} else if p.at(T!['[']) {501		p.eat(T!['['])?;502		let e = expr(p)?;503		p.eat(T![']'])?;504		Ok(FieldName::Dyn(e))505	} else {506		Err(p.error(format!("expected field name, got {}", p.current_desc())))507	}508}509510fn field(p: &mut Parser<'_>) -> Result<FieldMember> {511	let name = spanned(p, field_name)?;512513	if p.at(T!['(']) {514		p.eat(T!['('])?;515		let ps = params(p)?;516		p.eat(T![')'])?;517		let vis = visibility(p)?;518		let value = Rc::new(expr(p)?);519		Ok(FieldMember {520			name,521			plus: false,522			params: Some(ps),523			visibility: vis,524			value,525		})526	} else {527		let plus = p.try_eat(T![+]);528		let vis = visibility(p)?;529		let value = Rc::new(expr(p)?);530		Ok(FieldMember {531			name,532			plus,533			params: None,534			visibility: vis,535			value,536		})537	}538}539540fn member(p: &mut Parser<'_>) -> Result<Member> {541	if p.at(T![local]) {542		p.eat(T![local])?;543		Ok(Member::BindStmt(bind(p)?))544	} else if p.at(T![assert]) {545		Ok(Member::AssertStmt(assert_stmt(p)?))546	} else {547		Ok(Member::Field(field(p)?))548	}549}550551fn for_spec(p: &mut Parser<'_>) -> Result<ForSpecData> {552	p.eat(T![for])?;553	let d = destruct(p)?;554	p.eat(T![in])?;555	let over = expr(p)?;556	Ok(ForSpecData { destruct: d, over })557}558559fn compspecs(p: &mut Parser<'_>) -> Result<Vec<CompSpec>> {560	let mut specs = Vec::new();561	specs.push(CompSpec::ForSpec(for_spec(p)?));562	loop {563		if p.at(T![for]) {564			specs.push(CompSpec::ForSpec(for_spec(p)?));565		} else if p.at(T![if]) {566			let isd = if_spec_data(p)?;567			specs.push(CompSpec::IfSpec(isd));568		} else {569			break;570		}571	}572	Ok(specs)573}574575fn objinside(p: &mut Parser<'_>) -> Result<ObjBody> {576	if p.at(T!['}']) {577		return Ok(ObjBody::MemberList(ObjMembers {578			locals: Rc::new(Vec::new()),579			asserts: Rc::new(Vec::new()),580			fields: Vec::new(),581		}));582	}583584	let mut members = Vec::new();585	loop {586		members.push(member(p)?);587		if !p.try_eat(T![,]) {588			break;589		}590		if p.at(T!['}']) || p.at(T![for]) {591			break;592		}593	}594595	if p.at(T![for]) {596		let specs = compspecs(p)?;597		let mut locals = Vec::new();598		let mut field_member = None;599		for m in members {600			match m {601				Member::Field(f) => {602					if field_member.is_some() {603						return Err(604							p.error("object comprehension can only contain one field".into())605						);606					}607					field_member = Some(f);608				}609				Member::BindStmt(b) => locals.push(b),610				Member::AssertStmt(_) => {611					return Err(p.error("asserts are unsupported in object comprehension".into()));612				}613			}614		}615		Ok(ObjBody::ObjComp(ObjComp {616			locals: Rc::new(locals),617			field: Rc::new(618				field_member.ok_or_else(|| p.error("missing object comprehension field".into()))?,619			),620			compspecs: specs,621		}))622	} else {623		let mut locals = Vec::new();624		let mut asserts = Vec::new();625		let mut fields = Vec::new();626		for m in members {627			match m {628				Member::Field(f) => fields.push(f),629				Member::BindStmt(b) => locals.push(b),630				Member::AssertStmt(a) => asserts.push(a),631			}632		}633		Ok(ObjBody::MemberList(ObjMembers {634			locals: Rc::new(locals),635			asserts: Rc::new(asserts),636			fields,637		}))638	}639}640641fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {642	if let Some(lit) = literal(p) {643		return Ok(Expr::Literal(lit));644	}645646	match p.peek() {647		SyntaxKind::STRING_DOUBLE648		| SyntaxKind::STRING_SINGLE649		| SyntaxKind::STRING_DOUBLE_VERBATIM650		| SyntaxKind::STRING_SINGLE_VERBATIM651		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),652653		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),654655		T!['('] => {656			p.eat(T!['('])?;657			let e = expr(p)?;658			p.eat(T![')'])?;659			Ok(e)660		}661662		T!['['] => {663			p.eat(T!['['])?;664			if p.at(T![']']) {665				p.eat(T![']'])?;666				return Ok(Expr::Arr(Rc::new(Vec::new())));667			}668			let first = expr(p)?;669			if p.at(T![for]) {670				let specs = compspecs(p)?;671				p.eat(T![']'])?;672				Ok(Expr::ArrComp(Rc::new(first), specs))673			} else if p.at(T![,]) && {674				let next = p.offset + 1;675				next < p.lexemes.len() && p.lexemes[next].kind == T![for]676			} {677				p.eat(T![,])?;678				let specs = compspecs(p)?;679				p.eat(T![']'])?;680				Ok(Expr::ArrComp(Rc::new(first), specs))681			} else {682				let mut elems = vec![first];683				while p.try_eat(T![,]) {684					if p.at(T![']']) {685						break;686					}687					elems.push(expr(p)?);688				}689				p.eat(T![']'])?;690				Ok(Expr::Arr(Rc::new(elems)))691			}692		}693694		T!['{'] => {695			p.eat(T!['{'])?;696			let body = objinside(p)?;697			p.eat(T!['}'])?;698			Ok(Expr::Obj(body))699		}700701		T![local] => {702			p.eat(T![local])?;703			let mut binds = Vec::new();704			loop {705				binds.push(bind(p)?);706				if !p.try_eat(T![,]) {707					break;708				}709			}710			p.eat(T![;])?;711			let body = expr(p)?;712			Ok(Expr::LocalExpr(binds, Box::new(body)))713		}714715		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),716717		T![function] => {718			p.eat(T![function])?;719			p.eat(T!['('])?;720			let ps = params(p)?;721			p.eat(T![')'])?;722			let body = expr(p)?;723			Ok(Expr::Function(ps, Rc::new(body)))724		}725726		T![assert] => {727			let a = assert_stmt(p)?;728			p.eat(T![;])?;729			let rest = expr(p)?;730			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))731		}732733		T![error] => {734			let span = spanned(p, |p| p.eat(T![error]))?;735			let e = expr(p)?;736			Ok(Expr::ErrorStmt(span.span, Box::new(e)))737		}738739		T![importstr] => {740			let kind = spanned(p, |p| {741				p.eat(T![importstr])?;742				Ok(ImportKind::Str)743			})?;744			let path = expr(p)?;745			Ok(Expr::Import(kind, Box::new(path)))746		}747748		T![importbin] => {749			let kind = spanned(p, |p| {750				p.eat(T![importbin])?;751				Ok(ImportKind::Bin)752			})?;753			let path = expr(p)?;754			Ok(Expr::Import(kind, Box::new(path)))755		}756757		T![import] => {758			let kind = spanned(p, |p| {759				p.eat(T![import])?;760				Ok(ImportKind::Normal)761			})?;762			let path = expr(p)?;763			Ok(Expr::Import(kind, Box::new(path)))764		}765766		SyntaxKind::IDENT => {767			let text = p.text();768			let n = spanned(p, |p| {769				let s: IStr = p.text().into();770				p.eat_any();771				Ok(s)772			})?;773			Ok(Expr::Var(n))774		}775776		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),777	}778}779780fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {781	if parts.is_empty() {782		return;783	}784	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));785	*e = Expr::Index {786		indexable: Box::new(old),787		parts: std::mem::take(parts),788	};789}790791fn expr_suffix(p: &mut Parser<'_>) -> Result<Expr> {792	let mut e = expr_basic(p)?;793	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])794	// into a single Expr::Index. This is critical for null-coalesce semantics:795	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.796	let mut parts: Vec<IndexPart> = Vec::new();797798	loop {799		#[cfg(feature = "exp-null-coaelse")]800		if p.at(T![?]) {801			p.eat_any();802			if p.try_eat(T![.]) {803				if p.at(T!['[']) {804					// ?.[expr]805					p.eat(T!['['])?;806					let idx = spanned(p, expr)?;807					p.eat(T![']'])?;808					parts.push(IndexPart {809						span: idx.span,810						value: idx.value,811						null_coaelse: true,812					});813				} else {814					// ?.field815					let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;816					parts.push(IndexPart {817						span: id_spanned.span,818						value: id_spanned.value,819						null_coaelse: true,820					});821				}822			} else {823				return Err(p.error("expected '.' after '?'".into()));824			}825			continue;826		}827828		if p.at(T![.]) {829			p.eat(T![.])?;830			let id_spanned = spanned(p, |p| Ok(Expr::Str(ident(p)?)))?;831			parts.push(IndexPart {832				span: id_spanned.span,833				value: id_spanned.value,834				#[cfg(feature = "exp-null-coaelse")]835				null_coaelse: false,836			});837		} else if p.at(T!['[']) {838			p.eat(T!['['])?;839840			if p.at(T![:]) {841				// Slice: flush index parts first, then handle slice842				flush_index_parts(&mut e, &mut parts);843				let slice = slice_desc(p, None)?;844				p.eat(T![']'])?;845				e = Expr::Slice(Box::new(Slice { value: e, slice }));846			} else {847				let idx = spanned(p, expr)?;848				if p.at(T![:]) {849					// Slice with start: flush index parts first850					flush_index_parts(&mut e, &mut parts);851					let slice = slice_desc(p, Some(idx))?;852					p.eat(T![']'])?;853					e = Expr::Slice(Box::new(Slice { value: e, slice }));854				} else {855					// Bracket index: add to parts856					p.eat(T![']'])?;857					parts.push(IndexPart {858						span: idx.span,859						value: idx.value,860						#[cfg(feature = "exp-null-coaelse")]861						null_coaelse: false,862					});863				}864			}865		} else if p.at(T!['(']) {866			flush_index_parts(&mut e, &mut parts);867			let args_spanned = spanned(p, |p| {868				p.eat(T!['('])?;869				let a = args(p)?;870				p.eat(T![')'])?;871				Ok(a)872			})?;873			let tailstrict = p.try_eat(T![tailstrict]);874			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);875		} else if p.at(T!['{']) {876			flush_index_parts(&mut e, &mut parts);877			p.eat(T!['{'])?;878			let body = objinside(p)?;879			p.eat(T!['}'])?;880			e = Expr::ObjExtend(Rc::new(e), body);881		} else {882			break;883		}884	}885886	flush_index_parts(&mut e, &mut parts);887	Ok(e)888}889890fn prefix_binding_power(op: UnaryOpType) -> u8 {891	match op {892		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,893	}894}895896fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {897	match op {898		BinaryOpType::Or => (2, 3),899		#[cfg(feature = "exp-null-coaelse")]900		BinaryOpType::NullCoaelse => (2, 3),901		BinaryOpType::And => (4, 5),902		BinaryOpType::BitOr => (6, 7),903		BinaryOpType::BitXor => (8, 9),904		BinaryOpType::BitAnd => (10, 11),905		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),906		BinaryOpType::Lt907		| BinaryOpType::Gt908		| BinaryOpType::Lte909		| BinaryOpType::Gte910		| BinaryOpType::In => (14, 15),911		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),912		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),913		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),914	}915}916917fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {918	match kind {919		T![+] => Some(UnaryOpType::Plus),920		T![-] => Some(UnaryOpType::Minus),921		T![!] => Some(UnaryOpType::Not),922		T![~] => Some(UnaryOpType::BitNot),923		_ => None,924	}925}926927fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {928	match p.peek() {929		T![||] => Some(BinaryOpType::Or),930		T![&&] => Some(BinaryOpType::And),931		T![|] => Some(BinaryOpType::BitOr),932		T![^] => Some(BinaryOpType::BitXor),933		T![&] => Some(BinaryOpType::BitAnd),934		T![==] => Some(BinaryOpType::Eq),935		T![!=] => Some(BinaryOpType::Neq),936		T![<] => Some(BinaryOpType::Lt),937		T![>] => Some(BinaryOpType::Gt),938		T![<=] => Some(BinaryOpType::Lte),939		T![>=] => Some(BinaryOpType::Gte),940		T![<<] => Some(BinaryOpType::Lhs),941		T![>>] => Some(BinaryOpType::Rhs),942		T![+] => Some(BinaryOpType::Add),943		T![-] => Some(BinaryOpType::Sub),944		T![*] => Some(BinaryOpType::Mul),945		T![/] => Some(BinaryOpType::Div),946		T![%] => Some(BinaryOpType::Mod),947		T![in] => Some(BinaryOpType::In),948		#[cfg(feature = "exp-null-coaelse")]949		T![??] => Some(BinaryOpType::NullCoaelse),950		_ => None,951	}952}953954fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> Result<Expr> {955	let mut lhs = if let Some(op) = unary_op(p.peek()) {956		p.eat_any();957		let rbp = prefix_binding_power(op);958		let rhs = expr_bp(p, rbp)?;959		Expr::UnaryOp(op, Box::new(rhs))960	} else {961		expr_suffix(p)?962	};963964	loop {965		if p.at_eof() {966			break;967		}968969		let Some(op) = binary_op(p) else {970			break;971		};972973		let (lbp, rbp) = infix_binding_power(op);974		if lbp < min_bp {975			break;976		}977978		p.eat_any();979		let rhs = expr_bp(p, rbp)?;980		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));981	}982983	Ok(lhs)984}985986fn expr(p: &mut Parser<'_>) -> Result<Expr> {987	expr_bp(p, 0)988}989990pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr> {991	let mut p = Parser::new(str, settings.source.clone());992	for lexeme in &p.lexemes {993		if let Some(desc) = lexeme.kind.error_description() {994			return Err(ParseError {995				message: desc.to_owned(),996				location: lexeme.range,997			});998		}999	}1000	let e = expr(&mut p)?;1001	if !p.at_eof() {1002		return Err(p.error(format!("expected end of file, got {}", p.current_desc(),)));1003	}1004	Ok(e)1005}10061007pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {1008	let len = s.len();1009	Spanned::new(Expr::Str(s), Span(settings.source.clone(), 0, len as u32))1010}10111012#[cfg(test)]1013mod tests {1014	use std::fs;10151016	use insta::{assert_snapshot, glob};1017	use jrsonnet_ir::{IStr, Source};10181019	use super::*;10201021	fn parse_str(input: &str) -> Expr {1022		let source = Source::new_virtual("<test>".into(), input.into());1023		let settings = ParserSettings { source };1024		parse(input, &settings).unwrap()1025	}10261027	#[test]1028	#[cfg(not(feature = "exp-null-coaelse"))]1029	fn basic_test() {1030		let v = parse_str("assert true[false] : false ; true");1031		assert_snapshot!(format!("{v:#?}"));1032	}10331034	#[test]1035	fn literals() {1036		let v = parse_str("[null, true, false, self, super, $]");1037		assert_snapshot!(format!("{v:#?}"));1038	}10391040	#[test]1041	fn basic_math() {1042		let v = parse_str("2+2*2");1043		assert_snapshot!(format!("{v:#?}"));1044	}10451046	#[test]1047	fn underscore_numbers() {1048		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");1049		assert_snapshot!(format!("{v:#?}"));1050	}10511052	#[test]1053	fn strings() {1054		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1055		assert_snapshot!(format!("{v:#?}"));1056	}10571058	#[test]1059	fn object() {1060		let v = parse_str("{a: 1, b:: 2, c::: 3}");1061		assert_snapshot!(format!("{v:#?}"));1062	}10631064	#[test]1065	fn function_and_call() {1066		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1067		assert_snapshot!(format!("{v:#?}"));1068	}10691070	#[test]1071	fn if_then_else() {1072		let v = parse_str("if true then 1 else 2");1073		assert_snapshot!(format!("{v:#?}"));1074	}10751076	#[test]1077	fn imports() {1078		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1079		assert_snapshot!(format!("{v:#?}"));1080	}10811082	#[test]1083	fn array_comp() {1084		let v = parse_str("[x for x in arr]");1085		assert_snapshot!(format!("{v:#?}"));1086	}10871088	#[test]1089	#[cfg(not(feature = "exp-null-coaelse"))]1090	fn index_and_suffix() {1091		let v = parse_str("std.test(2).field[0]");1092		assert_snapshot!(format!("{v:#?}"));1093	}10941095	#[test]1096	fn obj_extend() {1097		let v = parse_str("{} { x: 1 }");1098		assert_snapshot!(format!("{v:#?}"));1099	}11001101	#[test]1102	fn unary_ops() {1103		let v = parse_str("!a && !b");1104		assert_snapshot!(format!("{v:#?}"));1105	}11061107	#[test]1108	fn error_expr() {1109		let v = parse_str("error \"bad\"");1110		assert_snapshot!(format!("{v:#?}"));1111	}11121113	#[test]1114	fn slice() {1115		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1116		assert_snapshot!(format!("{v:#?}"));1117	}11181119	#[test]1120	#[cfg(not(feature = "exp-null-coaelse"))]1121	fn peg_snapshots() {1122		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1123			let input = fs::read_to_string(path).expect("read test file");1124			let source = Source::new_virtual("<test>".into(), IStr::empty());1125			let settings = ParserSettings { source };1126			let v = parse(&input, &settings).unwrap();1127			let v = format!("{v:#?}");1128			assert_snapshot!(v);1129		});1130	}1131}