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

1use std::rc::Rc;23use jrsonnet_gcmodule::Acyclic;4use jrsonnet_ir::{5	unescape, ArgsDesc, AssertExpr, AssertStmt, BinaryOp, BinaryOpType, BindSpec, CompSpec,6	Destruct, Expr, ExprParam, ExprParams, FieldMember, FieldName, ForSpecData, IStr, IfElse,7	IfSpecData, ImportKind, IndexPart, LiteralType, Member, ObjBody, ObjComp, ObjMembers, Slice,8	SliceDesc, Source, Span, Spanned, UnaryOpType, Visibility,9};10use jrsonnet_lexer::{collect_lexed_str_block, Lexeme, Lexer, SyntaxKind, T};1112pub struct ParserSettings {13	pub source: Source,14}1516#[derive(Debug, Clone)]17pub struct ParseErrorLocation {18	pub offset: usize,19}2021#[derive(Debug, Clone)]22pub struct ParseError {23	pub message: String,24	pub location: ParseErrorLocation,25}2627impl std::fmt::Display for ParseError {28	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {29		write!(f, "{}", self.message)30	}31}3233type R<T> = Result<T, ParseError>;3435struct Parser<'a> {36	lexemes: Vec<Lexeme<'a>>,37	offset: usize,38	source: Source,39}4041impl<'a> Parser<'a> {42	fn new(code: &'a str, source: Source) -> Self {43		Self {44			lexemes: Lexer::new(code)45				.filter(|l| {46					!matches!(47						l.kind,48						SyntaxKind::WHITESPACE49							| SyntaxKind::SINGLE_LINE_SLASH_COMMENT50							| SyntaxKind::SINGLE_LINE_HASH_COMMENT51							| SyntaxKind::MULTI_LINE_COMMENT52					)53				})54				.collect(),55			offset: 0,56			source,57		}58	}5960	fn peek(&self) -> SyntaxKind {61		if self.at_eof() {62			SyntaxKind::EOF63		} else {64			self.lexemes[self.offset].kind65		}66	}6768	fn text(&self) -> &'a str {69		self.lexemes[self.offset].text70	}7172	fn at(&self, kind: SyntaxKind) -> bool {73		!self.at_eof() && self.peek() == kind74	}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) -> R<()> {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		ParseError {134			location: ParseErrorLocation {135				offset: self.span_start() as usize,136			},137			message,138		}139	}140141	fn expect_ident(&mut self) -> R<IStr> {142		if !self.at(SyntaxKind::IDENT) {143			return Err(self.error(format!("expected identifier, got {}", self.current_desc())));144		}145		let text = self.text();146		if is_reserved(text) {147			return Err(self.error(format!(148				"expected identifier, got reserved word '{text}'"149			)));150		}151		let s: IStr = text.into();152		self.eat_any();153		Ok(s)154	}155156	fn at_ident(&self) -> bool {157		self.at(SyntaxKind::IDENT) && !is_reserved(self.lexemes[self.offset].text)158	}159}160161fn is_reserved(s: &str) -> bool {162	matches!(163		s,164		"assert"165			| "else" | "error"166			| "false" | "for"167			| "function" | "if"168			| "import" | "importstr"169			| "importbin" | "in"170			| "local" | "null"171			| "tailstrict" | "then"172			| "self" | "super"173			| "true"174	)175}176177fn spanned<T: Acyclic>(p: &mut Parser<'_>, cb: impl FnOnce(&mut Parser<'_>) -> R<T>) -> R<Spanned<T>> {178	let start = p.span_start();179	let v = cb(p)?;180	let end = p.span_end();181	Ok(Spanned::new(v, Span(p.source.clone(), start, end)))182}183184fn parse_string_content(p: &mut Parser<'_>) -> R<IStr> {185	let kind = p.peek();186	let text = p.text();187	let s = match kind {188		SyntaxKind::STRING_DOUBLE => {189			let inner = &text[1..text.len() - 1];190			unescape::unescape(inner)191				.ok_or_else(|| p.error("invalid string escape".into()))?192		}193		SyntaxKind::STRING_SINGLE => {194			let inner = &text[1..text.len() - 1];195			unescape::unescape(inner)196				.ok_or_else(|| p.error("invalid string escape".into()))?197		}198		SyntaxKind::STRING_DOUBLE_VERBATIM => {199			let inner = &text[2..text.len() - 1];200			inner.replace("\"\"", "\"")201		}202		SyntaxKind::STRING_SINGLE_VERBATIM => {203			let inner = &text[2..text.len() - 1];204			inner.replace("''", "'")205		}206		SyntaxKind::STRING_BLOCK => {207			let inner = &text[3..];208			let collected = collect_lexed_str_block(inner)209				.map_err(|_| p.error("invalid string block".into()))?;210			let mut result = String::new();211			for (i, line) in collected.lines.iter().enumerate() {212				if i > 0 {213					result.push('\n');214				}215				result.push_str(line);216			}217			if !collected.truncate {218				result.push('\n');219			}220			result221		}222		_ => return Err(p.error(format!("expected string, got {}", p.current_desc()))),223	};224	p.eat_any();225	Ok(s.into())226}227228fn is_string_token(kind: SyntaxKind) -> bool {229	matches!(230		kind,231		SyntaxKind::STRING_DOUBLE232			| SyntaxKind::STRING_SINGLE233			| SyntaxKind::STRING_DOUBLE_VERBATIM234			| SyntaxKind::STRING_SINGLE_VERBATIM235			| SyntaxKind::STRING_BLOCK236	)237}238239fn parse_number(p: &mut Parser<'_>) -> R<f64> {240	let text = p.text();241	let n: f64 = text242		.replace('_', "")243		.parse()244		.map_err(|_| p.error(format!("invalid number literal: {text}")))?;245	if !n.is_finite() {246		return Err(p.error("numbers are finite".into()));247	}248	p.eat_any();249	Ok(n)250}251252fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {253	let t = match p.peek() {254		T![self] => LiteralType::This,255		T![super] => LiteralType::Super,256		T!['$'] => LiteralType::Dollar,257		T![null] => LiteralType::Null,258		T![true] => LiteralType::True,259		T![false] => LiteralType::False,260		_ => return None,261	};262	p.eat_any();263	Some(t)264}265266fn assert_stmt(p: &mut Parser<'_>) -> R<AssertStmt> {267	p.eat(T![assert])?;268	let cond = spanned(p, expr)?;269	let msg = if p.try_eat(T![:]) {270		Some(spanned(p, expr)?)271	} else {272		None273	};274	Ok(AssertStmt(cond, msg))275}276277fn if_spec_data(p: &mut Parser<'_>) -> R<IfSpecData> {278	let v = spanned(p, |p| p.eat(T![if]))?;279	let cond = expr(p)?;280	Ok(IfSpecData { span: v.span, cond })281}282283fn if_else(p: &mut Parser<'_>) -> R<IfElse> {284	let cond = if_spec_data(p)?;285	p.eat(T![then])?;286	let cond_then = expr(p)?;287	let cond_else = if p.try_eat(T![else]) {288		Some(expr(p)?)289	} else {290		None291	};292	Ok(IfElse {293		cond,294		cond_then,295		cond_else,296	})297}298299fn slice_desc(p: &mut Parser<'_>, start: Option<Spanned<Expr>>) -> R<SliceDesc> {300	p.eat(T![:])?;301	let end = if !p.at(T![:]) && !p.at(T![']']) {302		Some(spanned(p, expr)?)303	} else {304		None305	};306	let step = if p.try_eat(T![:]) {307		if !p.at(T![']']) {308			Some(spanned(p, expr)?)309		} else {310			None311		}312	} else {313		None314	};315	Ok(SliceDesc { start, end, step })316}317318fn destruct(p: &mut Parser<'_>) -> R<Destruct> {319	Ok(Destruct::Full(p.expect_ident()?))320}321322fn params(p: &mut Parser<'_>) -> R<ExprParams> {323	if p.at(T![')']) {324		return Ok(ExprParams::new(Vec::new()));325	}326	let mut result = Vec::new();327	loop {328		let d = destruct(p)?;329		let default = if p.try_eat(T![=]) {330			Some(Rc::new(expr(p)?))331		} else {332			None333		};334		result.push(ExprParam {335			destruct: d,336			default,337		});338		if !p.try_eat(T![,]) {339			break;340		}341		if p.at(T![')']) {342			break;343		}344	}345	Ok(ExprParams::new(result))346}347348fn args(p: &mut Parser<'_>) -> R<ArgsDesc> {349	if p.at(T![')']) {350		return Ok(ArgsDesc::new(Vec::new(), Vec::new()));351	}352	let mut unnamed = Vec::new();353	let mut named = Vec::new();354	let mut named_started = false;355	loop {356		let is_named = p.at_ident() && {357			let next_offset = p.offset + 1;358			next_offset < p.lexemes.len() && p.lexemes[next_offset].kind == T![=] && {359				let after_eq = next_offset + 1;360				after_eq >= p.lexemes.len() || p.lexemes[after_eq].kind != T![=]361			}362		};363		if is_named {364			let name: IStr = p.expect_ident()?;365			p.eat(T![=])?;366			let value = Rc::new(expr(p)?);367			named.push((name, value));368			named_started = true;369		} else {370			if named_started {371				return Err(p.error("positional argument after named argument".into()));372			}373			unnamed.push(Rc::new(expr(p)?));374		}375		if !p.try_eat(T![,]) {376			break;377		}378		if p.at(T![')']) {379			break;380		}381	}382	Ok(ArgsDesc::new(unnamed, named))383}384385fn bind(p: &mut Parser<'_>) -> R<BindSpec> {386	let name = p.expect_ident()?;387	if p.try_eat(T!['(']) {388		let ps = params(p)?;389		p.eat(T![')'])?;390		p.eat(T![=])?;391		let value = Rc::new(expr(p)?);392		Ok(BindSpec::Function {393			name,394			params: ps,395			value,396		})397	} else {398		p.eat(T![=])?;399		let value = Rc::new(expr(p)?);400		Ok(BindSpec::Field {401			into: Destruct::Full(name),402			value,403		})404	}405}406407fn visibility(p: &mut Parser<'_>) -> R<Visibility> {408	p.eat(T![:])?;409	if p.try_eat(T![:]) {410		if p.try_eat(T![:]) {411			Ok(Visibility::Unhide)412		} else {413			Ok(Visibility::Hidden)414		}415	} else {416		Ok(Visibility::Normal)417	}418}419420fn field_name(p: &mut Parser<'_>) -> R<FieldName> {421	if p.at_ident() {422		Ok(FieldName::Fixed(p.expect_ident()?))423	} else if is_string_token(p.peek()) {424		Ok(FieldName::Fixed(parse_string_content(p)?))425	} else if p.at(T!['[']) {426		p.eat(T!['['])?;427		let e = expr(p)?;428		p.eat(T![']'])?;429		Ok(FieldName::Dyn(e))430	} else {431		Err(p.error(format!("expected field name, got {}", p.current_desc())))432	}433}434435fn field(p: &mut Parser<'_>) -> R<FieldMember> {436	let name = spanned(p, field_name)?;437438	if p.at(T!['(']) {439		p.eat(T!['('])?;440		let ps = params(p)?;441		p.eat(T![')'])?;442		let vis = visibility(p)?;443		let value = Rc::new(expr(p)?);444		Ok(FieldMember {445			name,446			plus: false,447			params: Some(ps),448			visibility: vis,449			value,450		})451	} else {452		let plus = p.try_eat(T![+]);453		let vis = visibility(p)?;454		let value = Rc::new(expr(p)?);455		Ok(FieldMember {456			name,457			plus,458			params: None,459			visibility: vis,460			value,461		})462	}463}464465fn member(p: &mut Parser<'_>) -> R<Member> {466	if p.at(T![local]) {467		p.eat(T![local])?;468		Ok(Member::BindStmt(bind(p)?))469	} else if p.at(T![assert]) {470		Ok(Member::AssertStmt(assert_stmt(p)?))471	} else {472		Ok(Member::Field(field(p)?))473	}474}475476fn for_spec(p: &mut Parser<'_>) -> R<ForSpecData> {477	p.eat(T![for])?;478	let d = destruct(p)?;479	p.eat(T![in])?;480	let over = expr(p)?;481	Ok(ForSpecData { destruct: d, over })482}483484fn compspecs(p: &mut Parser<'_>) -> R<Vec<CompSpec>> {485	let mut specs = Vec::new();486	specs.push(CompSpec::ForSpec(for_spec(p)?));487	loop {488		if p.at(T![for]) {489			specs.push(CompSpec::ForSpec(for_spec(p)?));490		} else if p.at(T![if]) {491			let isd = if_spec_data(p)?;492			specs.push(CompSpec::IfSpec(isd));493		} else {494			break;495		}496	}497	Ok(specs)498}499500fn objinside(p: &mut Parser<'_>) -> R<ObjBody> {501	if p.at(T!['}']) {502		return Ok(ObjBody::MemberList(ObjMembers {503			locals: Rc::new(Vec::new()),504			asserts: Rc::new(Vec::new()),505			fields: Vec::new(),506		}));507	}508509	let mut members = Vec::new();510	loop {511		members.push(member(p)?);512		if !p.try_eat(T![,]) {513			break;514		}515		if p.at(T!['}']) || p.at(T![for]) {516			break;517		}518	}519520	if p.at(T![for]) {521		let specs = compspecs(p)?;522		let mut locals = Vec::new();523		let mut field_member = None;524		for m in members {525			match m {526				Member::Field(f) => {527					if field_member.is_some() {528						return Err(p.error(529							"object comprehension can only contain one field".into(),530						));531					}532					field_member = Some(f);533				}534				Member::BindStmt(b) => locals.push(b),535				Member::AssertStmt(_) => {536					return Err(p.error(537						"asserts are unsupported in object comprehension".into(),538					));539				}540			}541		}542		Ok(ObjBody::ObjComp(ObjComp {543			locals: Rc::new(locals),544			field: Rc::new(545				field_member.ok_or_else(|| {546					p.error("missing object comprehension field".into())547				})?,548			),549			compspecs: specs,550		}))551	} else {552		let mut locals = Vec::new();553		let mut asserts = Vec::new();554		let mut fields = Vec::new();555		for m in members {556			match m {557				Member::Field(f) => fields.push(f),558				Member::BindStmt(b) => locals.push(b),559				Member::AssertStmt(a) => asserts.push(a),560			}561		}562		Ok(ObjBody::MemberList(ObjMembers {563			locals: Rc::new(locals),564			asserts: Rc::new(asserts),565			fields,566		}))567	}568}569570fn expr_basic(p: &mut Parser<'_>) -> R<Expr> {571	if let Some(lit) = literal(p) {572		return Ok(Expr::Literal(lit));573	}574575	match p.peek() {576		SyntaxKind::STRING_DOUBLE577		| SyntaxKind::STRING_SINGLE578		| SyntaxKind::STRING_DOUBLE_VERBATIM579		| SyntaxKind::STRING_SINGLE_VERBATIM580		| SyntaxKind::STRING_BLOCK => Ok(Expr::Str(parse_string_content(p)?)),581582		SyntaxKind::FLOAT => Ok(Expr::Num(parse_number(p)?)),583584		T!['('] => {585			p.eat(T!['('])?;586			let e = expr(p)?;587			p.eat(T![')'])?;588			Ok(e)589		}590591		T!['['] => {592			p.eat(T!['['])?;593			if p.at(T![']']) {594				p.eat(T![']'])?;595				return Ok(Expr::Arr(Rc::new(Vec::new())));596			}597			let first = expr(p)?;598			if p.at(T![for]) {599				let specs = compspecs(p)?;600				p.eat(T![']'])?;601				Ok(Expr::ArrComp(Rc::new(first), specs))602			} else if p.at(T![,]) && {603				let next = p.offset + 1;604				next < p.lexemes.len() && p.lexemes[next].kind == T![for]605			} {606				p.eat(T![,])?;607				let specs = compspecs(p)?;608				p.eat(T![']'])?;609				Ok(Expr::ArrComp(Rc::new(first), specs))610			} else {611				let mut elems = vec![first];612				while p.try_eat(T![,]) {613					if p.at(T![']']) {614						break;615					}616					elems.push(expr(p)?);617				}618				p.eat(T![']'])?;619				Ok(Expr::Arr(Rc::new(elems)))620			}621		}622623		T!['{'] => {624			p.eat(T!['{'])?;625			let body = objinside(p)?;626			p.eat(T!['}'])?;627			Ok(Expr::Obj(body))628		}629630		T![local] => {631			p.eat(T![local])?;632			let mut binds = Vec::new();633			loop {634				binds.push(bind(p)?);635				if !p.try_eat(T![,]) {636					break;637				}638			}639			p.eat(T![;])?;640			let body = expr(p)?;641			Ok(Expr::LocalExpr(binds, Box::new(body)))642		}643644		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),645646		T![function] => {647			p.eat(T![function])?;648			p.eat(T!['('])?;649			let ps = params(p)?;650			p.eat(T![')'])?;651			let body = expr(p)?;652			Ok(Expr::Function(ps, Rc::new(body)))653		}654655		T![assert] => {656			let a = assert_stmt(p)?;657			p.eat(T![;])?;658			let rest = expr(p)?;659			Ok(Expr::AssertExpr(Rc::new(AssertExpr { assert: a, rest })))660		}661662		T![error] => {663			let span = spanned(p, |p| p.eat(T![error]))?;664			let e = expr(p)?;665			Ok(Expr::ErrorStmt(span.span, Box::new(e)))666		}667668		T![importstr] => {669			let kind = spanned(p, |p| {670				p.eat(T![importstr])?;671				Ok(ImportKind::Str)672			})?;673			let path = expr(p)?;674			Ok(Expr::Import(kind, Box::new(path)))675		}676677		T![importbin] => {678			let kind = spanned(p, |p| {679				p.eat(T![importbin])?;680				Ok(ImportKind::Bin)681			})?;682			let path = expr(p)?;683			Ok(Expr::Import(kind, Box::new(path)))684		}685686		T![import] => {687			let kind = spanned(p, |p| {688				p.eat(T![import])?;689				Ok(ImportKind::Normal)690			})?;691			let path = expr(p)?;692			Ok(Expr::Import(kind, Box::new(path)))693		}694695		SyntaxKind::IDENT => {696			let text = p.text();697			if is_reserved(text) {698				return Err(p.error(format!("unexpected reserved word '{text}'")));699			}700			let n = spanned(p, |p| {701				let s: IStr = p.text().into();702				p.eat_any();703				Ok(s)704			})?;705			Ok(Expr::Var(n))706		}707708		_ => Err(p.error(format!("unexpected {}", p.current_desc()))),709	}710}711712/// Flush accumulated index parts into an Expr::Index wrapping `e`.713fn flush_index_parts(e: &mut Expr, parts: &mut Vec<IndexPart>) {714	if parts.is_empty() {715		return;716	}717	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));718	*e = Expr::Index {719		indexable: Box::new(old),720		parts: std::mem::take(parts),721	};722}723724fn expr_suffix(p: &mut Parser<'_>) -> R<Expr> {725	let mut e = expr_basic(p)?;726	// Accumulate consecutive index parts (.field, [expr], ?.field, ?.[expr])727	// into a single Expr::Index. This is critical for null-coalesce semantics:728	// a?.b.c needs all parts in one Index so the evaluator can skip .c when .b is null.729	let mut parts: Vec<IndexPart> = Vec::new();730731	loop {732		#[cfg(feature = "exp-null-coaelse")]733		if p.at(T![?]) {734			p.eat_any();735			if p.try_eat(T![.]) {736				if p.at(T!['[']) {737					// ?.[expr]738					p.eat(T!['['])?;739					let idx = spanned(p, expr)?;740					p.eat(T![']'])?;741					parts.push(IndexPart {742						span: idx.span,743						value: idx.value,744						null_coaelse: true,745					});746				} else {747					// ?.field748					let id_spanned = spanned(p, |p| {749						let name = p.expect_ident()?;750						Ok(Expr::Str(name))751					})?;752					parts.push(IndexPart {753						span: id_spanned.span,754						value: id_spanned.value,755						null_coaelse: true,756					});757				}758			} else {759				return Err(p.error("expected '.' after '?'".into()));760			}761			continue;762		}763764		if p.at(T![.]) {765			p.eat(T![.])?;766			let id_spanned = spanned(p, |p| {767				let name = p.expect_ident()?;768				Ok(Expr::Str(name))769			})?;770			parts.push(IndexPart {771				span: id_spanned.span,772				value: id_spanned.value,773				#[cfg(feature = "exp-null-coaelse")]774				null_coaelse: false,775			});776		} else if p.at(T!['[']) {777			p.eat(T!['['])?;778779			if p.at(T![:]) {780				// Slice: flush index parts first, then handle slice781				flush_index_parts(&mut e, &mut parts);782				let slice = slice_desc(p, None)?;783				p.eat(T![']'])?;784				e = Expr::Slice(Box::new(Slice { value: e, slice }));785			} else {786				let idx = spanned(p, expr)?;787				if p.at(T![:]) {788					// Slice with start: flush index parts first789					flush_index_parts(&mut e, &mut parts);790					let slice = slice_desc(p, Some(idx))?;791					p.eat(T![']'])?;792					e = Expr::Slice(Box::new(Slice { value: e, slice }));793				} else {794					// Bracket index: add to parts795					p.eat(T![']'])?;796					parts.push(IndexPart {797						span: idx.span,798						value: idx.value,799						#[cfg(feature = "exp-null-coaelse")]800						null_coaelse: false,801					});802				}803			}804		} else if p.at(T!['(']) {805			flush_index_parts(&mut e, &mut parts);806			let args_spanned = spanned(p, |p| {807				p.eat(T!['('])?;808				let a = args(p)?;809				p.eat(T![')'])?;810				Ok(a)811			})?;812			let tailstrict = p.try_eat(T![tailstrict]);813			e = Expr::Apply(Box::new(e), args_spanned, tailstrict);814		} else if p.at(T!['{']) {815			flush_index_parts(&mut e, &mut parts);816			p.eat(T!['{'])?;817			let body = objinside(p)?;818			p.eat(T!['}'])?;819			e = Expr::ObjExtend(Rc::new(e), body);820		} else {821			break;822		}823	}824825	flush_index_parts(&mut e, &mut parts);826	Ok(e)827}828829fn prefix_binding_power(op: UnaryOpType) -> u8 {830	match op {831		UnaryOpType::Plus | UnaryOpType::Minus | UnaryOpType::Not | UnaryOpType::BitNot => 20,832	}833}834835fn infix_binding_power(op: BinaryOpType) -> (u8, u8) {836	match op {837		BinaryOpType::Or => (2, 3),838		#[cfg(feature = "exp-null-coaelse")]839		BinaryOpType::NullCoaelse => (2, 3),840		BinaryOpType::And => (4, 5),841		BinaryOpType::BitOr => (6, 7),842		BinaryOpType::BitXor => (8, 9),843		BinaryOpType::BitAnd => (10, 11),844		BinaryOpType::Eq | BinaryOpType::Neq => (12, 13),845		BinaryOpType::Lt846		| BinaryOpType::Gt847		| BinaryOpType::Lte848		| BinaryOpType::Gte849		| BinaryOpType::In => (14, 15),850		BinaryOpType::Lhs | BinaryOpType::Rhs => (16, 17),851		BinaryOpType::Add | BinaryOpType::Sub => (18, 19),852		BinaryOpType::Mul | BinaryOpType::Div | BinaryOpType::Mod => (20, 21),853	}854}855856fn unary_op(kind: SyntaxKind) -> Option<UnaryOpType> {857	match kind {858		T![+] => Some(UnaryOpType::Plus),859		T![-] => Some(UnaryOpType::Minus),860		T![!] => Some(UnaryOpType::Not),861		T![~] => Some(UnaryOpType::BitNot),862		_ => None,863	}864}865866fn binary_op(p: &Parser<'_>) -> Option<BinaryOpType> {867	match p.peek() {868		T![||] => Some(BinaryOpType::Or),869		T![&&] => Some(BinaryOpType::And),870		T![|] => Some(BinaryOpType::BitOr),871		T![^] => Some(BinaryOpType::BitXor),872		T![&] => Some(BinaryOpType::BitAnd),873		T![==] => Some(BinaryOpType::Eq),874		T![!=] => Some(BinaryOpType::Neq),875		T![<] => Some(BinaryOpType::Lt),876		T![>] => Some(BinaryOpType::Gt),877		T![<=] => Some(BinaryOpType::Lte),878		T![>=] => Some(BinaryOpType::Gte),879		T![<<] => Some(BinaryOpType::Lhs),880		T![>>] => Some(BinaryOpType::Rhs),881		T![+] => Some(BinaryOpType::Add),882		T![-] => Some(BinaryOpType::Sub),883		T![*] => Some(BinaryOpType::Mul),884		T![/] => Some(BinaryOpType::Div),885		T![%] => Some(BinaryOpType::Mod),886		T![in] => Some(BinaryOpType::In),887		#[cfg(feature = "exp-null-coaelse")]888		T![??] => Some(BinaryOpType::NullCoaelse),889		_ => None,890	}891}892893fn expr_bp(p: &mut Parser<'_>, min_bp: u8) -> R<Expr> {894	let mut lhs = if let Some(op) = unary_op(p.peek()) {895		p.eat_any();896		let rbp = prefix_binding_power(op);897		let rhs = expr_bp(p, rbp)?;898		Expr::UnaryOp(op, Box::new(rhs))899	} else {900		expr_suffix(p)?901	};902903	loop {904		if p.at_eof() {905			break;906		}907908		let Some(op) = binary_op(p) else {909			break;910		};911912		let (lbp, rbp) = infix_binding_power(op);913		if lbp < min_bp {914			break;915		}916917		p.eat_any();918		let rhs = expr_bp(p, rbp)?;919		lhs = Expr::BinaryOp(Box::new(BinaryOp { lhs, op, rhs }));920	}921922	Ok(lhs)923}924925fn expr(p: &mut Parser<'_>) -> R<Expr> {926	expr_bp(p, 0)927}928929pub fn parse(str: &str, settings: &ParserSettings) -> Result<Expr, ParseError> {930	let mut p = Parser::new(str, settings.source.clone());931	for lexeme in &p.lexemes {932		if let Some(desc) = lexeme.kind.error_description() {933			return Err(ParseError {934				message: desc.to_owned(),935				location: ParseErrorLocation {936					offset: lexeme.range.0 as usize,937				},938			});939		}940	}941	let e = expr(&mut p)?;942	if !p.at_eof() {943		return Err(p.error(format!(944			"expected end of file, got {}",945			p.current_desc(),946		)));947	}948	Ok(e)949}950951pub fn string_to_expr(s: IStr, settings: &ParserSettings) -> Spanned<Expr> {952	let len = s.len();953	Spanned::new(954		Expr::Str(s),955		Span(settings.source.clone(), 0, len as u32),956	)957}958959#[cfg(test)]960mod tests {961	use std::fs;962963	use insta::{assert_snapshot, glob};964	use jrsonnet_ir::{IStr, Source};965966	use super::*;967968	fn parse_str(input: &str) -> Expr {969		let source = Source::new_virtual("<test>".into(), input.into());970		let settings = ParserSettings { source };971		parse(input, &settings).unwrap()972	}973974	#[test]975	#[cfg(not(feature = "exp-null-coaelse"))]976	fn basic_test() {977		let v = parse_str("assert true[false] : false ; true");978		assert_snapshot!(format!("{v:#?}"));979	}980981	#[test]982	fn literals() {983		let v = parse_str("[null, true, false, self, super, $]");984		assert_snapshot!(format!("{v:#?}"));985	}986987	#[test]988	fn basic_math() {989		let v = parse_str("2+2*2");990		assert_snapshot!(format!("{v:#?}"));991	}992993	#[test]994	fn underscore_numbers() {995		let v = parse_str("[1_000, 1_000.000_1, 1_0e1_0]");996		assert_snapshot!(format!("{v:#?}"));997	}998999	#[test]1000	fn strings() {1001		let v = parse_str(r#"["hello", 'world', @"raw""str", @'raw''str']"#);1002		assert_snapshot!(format!("{v:#?}"));1003	}10041005	#[test]1006	fn object() {1007		let v = parse_str("{a: 1, b:: 2, c::: 3}");1008		assert_snapshot!(format!("{v:#?}"));1009	}10101011	#[test]1012	fn function_and_call() {1013		let v = parse_str("local f(x, y=1) = x + y; f(2, y=3)");1014		assert_snapshot!(format!("{v:#?}"));1015	}10161017	#[test]1018	fn if_then_else() {1019		let v = parse_str("if true then 1 else 2");1020		assert_snapshot!(format!("{v:#?}"));1021	}10221023	#[test]1024	fn imports() {1025		let v = parse_str(r#"[import "a", importstr "b", importbin "c"]"#);1026		assert_snapshot!(format!("{v:#?}"));1027	}10281029	#[test]1030	fn array_comp() {1031		let v = parse_str("[x for x in arr]");1032		assert_snapshot!(format!("{v:#?}"));1033	}10341035	#[test]1036	#[cfg(not(feature = "exp-null-coaelse"))]1037	fn index_and_suffix() {1038		let v = parse_str("std.test(2).field[0]");1039		assert_snapshot!(format!("{v:#?}"));1040	}10411042	#[test]1043	fn obj_extend() {1044		let v = parse_str("{} { x: 1 }");1045		assert_snapshot!(format!("{v:#?}"));1046	}10471048	#[test]1049	fn unary_ops() {1050		let v = parse_str("!a && !b");1051		assert_snapshot!(format!("{v:#?}"));1052	}10531054	#[test]1055	fn error_expr() {1056		let v = parse_str("error \"bad\"");1057		assert_snapshot!(format!("{v:#?}"));1058	}10591060	#[test]1061	fn slice() {1062		let v = parse_str("[a[1:], a[1::], a[:1:], a[::1]]");1063		assert_snapshot!(format!("{v:#?}"));1064	}10651066	#[test]1067	#[cfg(not(feature = "exp-null-coaelse"))]1068	fn peg_snapshots() {1069		glob!("../../jrsonnet-peg-parser/src", "tests/*.jsonnet", |path| {1070			let input = fs::read_to_string(path).expect("read test file");1071			let source = Source::new_virtual("<test>".into(), IStr::empty());1072			let settings = ParserSettings { source };1073			let v = parse(&input, &settings).unwrap();1074			let v = format!("{v:#?}");1075			assert_snapshot!(v);1076		});1077	}1078}