git.delta.rocks / jrsonnet / refs/commits / 40875769025f

472		match bind {472		match bind {
473			BindSpec::Field { into, .. } => self.alloc_destruct(into),473			BindSpec::Field { into, .. } => self.alloc_destruct(into),
474			BindSpec::Function { name, .. } => {474			BindSpec::Function { name, .. } => {
475				let (_, id) = self.define_local(name.clone(), None)?;475				let (_, id) = self.define_local(name.value.clone(), Some(name.span.clone()))?;
476				Some(LDestruct::Full(id))476				Some(LDestruct::Full(id))
477			}477			}
478		}478		}
1337	stack: &mut AnalysisStack,1337	stack: &mut AnalysisStack,
1338	taint: &mut AnalysisResult,1338	taint: &mut AnalysisResult,
1339) -> LExpr {1339) -> LExpr {
1340	if let Expr::Function(params, body) = expr {1340	if let Expr::Function(span, params, body) = expr {
1341		return analyze_function(Some(name), params, body, stack, taint);1341		return analyze_function(Some(name), &span, &params, body, stack, taint);
1342	}1342	}
1343	analyze(expr, stack, taint)1343	analyze(expr, stack, taint)
1344}1344}
1345#[allow(clippy::too_many_lines)]1345#[allow(clippy::too_many_lines)]
1346pub fn analyze(expr: &Expr, stack: &mut AnalysisStack, taint: &mut AnalysisResult) -> LExpr {1346pub fn analyze(expr: &Expr, stack: &mut AnalysisStack, taint: &mut AnalysisResult) -> LExpr {
1347	match expr {1347	match expr {
1348		Expr::Literal(l) => match l {1348		Expr::Literal(span, l) => match l {
1349			LiteralType::This => stack.use_this(taint).map_or_else(1349			LiteralType::This => stack.use_this(taint).map_or_else(
1350				|| {1350				|| {
1351					stack.report_error("`self` used outside of object", None);1351					stack.report_error("`self` used outside of object", Some(span.clone()));
1352					LExpr::BadLocal("self")1352					LExpr::BadLocal("self")
1353				},1353				},
1354				LExpr::Slot,1354				LExpr::Slot,
1357				if stack.use_super(taint).is_some() {1357				if stack.use_super(taint).is_some() {
1358					LExpr::Super1358					LExpr::Super
1359				} else {1359				} else {
1360					stack.report_error("`super` used outside of object", None);1360					stack.report_error("`super` used outside of object", Some(span.clone()));
1361					LExpr::BadLocal("super")1361					LExpr::BadLocal("super")
1362				}1362				}
1363			}1363			}
1364			LiteralType::Dollar => stack.use_dollar(taint).map_or_else(1364			LiteralType::Dollar => stack.use_dollar(taint).map_or_else(
1365				|| {1365				|| {
1366					stack.report_error("`$` used outside of object", None);1366					stack.report_error("`$` used outside of object", Some(span.clone()));
1367					LExpr::BadLocal("$")1367					LExpr::BadLocal("$")
1368				},1368				},
1369				LExpr::Slot,1369				LExpr::Slot,
1475				parts: parts_l,1475				parts: parts_l,
1476			}1476			}
1477		}1477		}
1478		Expr::Function(params, body) => analyze_function(None, params, body, stack, taint),1478		Expr::Function(span, params, body) => {
1479			analyze_function(None, span, params, body, stack, taint)
1480		}
1479		Expr::IfElse(ifelse) => {1481		Expr::IfElse(ifelse) => {
1480			let IfElse {1482			let IfElse {
1481				cond,1483				cond,
1541) -> LExpr {1543) -> LExpr {
1542	match bind {1544	match bind {
1543		BindSpec::Field {1545		BindSpec::Field {
1544			value: Expr::Function(params, value),1546			value: Expr::Function(span, params, value),
1545			into: Destruct::Full(name),1547			into: Destruct::Full(name),
1546		} => analyze_function(Some(name.value.clone()), params, value, stack, taint),1548		} => analyze_function(Some(name.value.clone()), &span, params, value, stack, taint),
1547		BindSpec::Field { value, .. } => analyze(value, stack, taint),1549		BindSpec::Field { value, .. } => analyze(value, stack, taint),
1548		BindSpec::Function {1550		BindSpec::Function {
1549			params,1551			params,
1550			value,1552			value,
1551			name,1553			name,
1552		} => analyze_function(Some(name.clone()), params, value, stack, taint),1554		} => analyze_function(
1555			Some(name.value.clone()),
1556			&name.span,
1557			params,
1558			value,
1559			stack,
1560			taint,
1561		),
1553	}1562	}
1554}1563}
15951604
1596fn analyze_function(1605fn analyze_function(
1597	name: Option<IStr>,1606	name: Option<IStr>,
1607	span: &Span,
1598	params: &ExprParams,1608	params: &ExprParams,
1599	body: &Expr,1609	body: &Expr,
1600	stack: &mut AnalysisStack,1610	stack: &mut AnalysisStack,
16481658
1649	// function(x) x is an identity function1659	// function(x) x is an identity function
1650	if l_params.len() == 1 && l_params[0].default.is_none() {1660	if l_params.len() == 1 && l_params[0].default.is_none() {
1651		stack.report_warning(
1652			"do not define identity functions manually, use std.id instead",
1653			None,
1654		);
1655		#[allow(irrefutable_let_patterns, reason = "refutable with exp-destruct")]1661		#[allow(irrefutable_let_patterns, reason = "refutable with exp-destruct")]
1656		if let LDestruct::Full(param_slot) = &l_params[0].destruct1662		if let LDestruct::Full(param_slot) = &l_params[0].destruct
1657			&& let LExpr::Slot(LSlot::Local(s)) = &body_expr1663			&& let LExpr::Slot(LSlot::Local(s)) = &body_expr
1658			&& s == param_slot1664			&& s == param_slot
1659		{1665		{
1666			stack.report_warning(
1667				"do not define identity functions manually, use std.id instead",
1668				Some(span.clone()),
1669			);
1660			return LExpr::IdentityFunction {};1670			return LExpr::IdentityFunction {};
1661		}1671		}
1662	}1672	}
1729						if let Some(params) = &f.params {1739						if let Some(params) = &f.params {
1730							analyze_function(name.function_name(), params, &f.value, stack, taint)1740							analyze_function(
1741								name.function_name(),
1742								&f.name.span,
1743								params,
1744								&f.value,
1745								stack,
1746								taint,
1747							)
1731						} else {1748						} else {
1732							analyze(&f.value, stack, taint)1749							analyze(&f.value, stack, taint)
1773					if let Some(params) = &comp.field.params {1790					if let Some(params) = &comp.field.params {
1774						analyze_function(None, params, &comp.field.value, stack, taint)1791						analyze_function(
1792							None,
1793							&comp.field.name.span,
1794							params,
1795							&comp.field.value,
1796							stack,
1797							taint,
1798						)
1775					} else {1799					} else {
1776						analyze(&comp.field.value, stack, taint)1800						analyze(&comp.field.value, stack, taint)

7};7};
88
9use jrsonnet_gcmodule::Trace;9use jrsonnet_gcmodule::Trace;
10use jrsonnet_ir::CodeLocation;10use jrsonnet_ir::{CodeLocation, Span};
11#[cfg(feature = "explaining-traces")]
12use jrsonnet_ir::Span;
1311
14use crate::{Error, ResolvePathOwned, error::ErrorKind};12use crate::{Error, ResolvePathOwned, analyze::DiagLevel, error::ErrorKind};
1513
16/// The way paths should be displayed14/// The way paths should be displayed
17#[derive(Clone, Trace)]15#[derive(Clone, Trace)]
72	fn as_any_mut(&mut self) -> &mut dyn Any;70	fn as_any_mut(&mut self) -> &mut dyn Any;
73}71}
72
73fn span_label(resolver: &PathResolver, span: &Span) -> String {
74	use std::fmt::Write;
75	let mut path = span
76		.0
77		.source_path()
78		.path()
79		.map_or_else(|| span.0.source_path().to_string(), |p| resolver.resolve(p));
80	#[expect(clippy::cast_possible_truncation, reason = "code is limited by 4gb")]
81	let len = span.0.code().len() as u32;
82	let start = span.1.min(len);
83	let end = span.2.min(len);
84	let (start_loc, end_loc) = if start == end {
85		let [loc] = span.0.map_source_locations(&[start]);
86		(loc, loc)
87	} else {
88		let [s, e] = span.0.map_source_locations(&[start, end]);
89		(s, e)
90	};
91	write!(path, ":").unwrap();
92	print_code_location(&mut path, &start_loc, &end_loc).unwrap();
93	path
94}
95
96#[cfg(feature = "explaining-traces")]
97fn span_render_range(span: &Span) -> Option<std::ops::RangeInclusive<usize>> {
98	let len = span.0.code().len();
99	if len == 0 {
100		return None;
101	}
102	let max = len - 1;
103	let r = span.range();
104	Some((*r.start()).min(max)..=(*r.end()).min(max))
105}
106
107fn diag_level_label(level: DiagLevel) -> &'static str {
108	match level {
109		DiagLevel::Error => "error",
110		DiagLevel::Warning => "warning",
111	}
112}
74113
75fn print_code_location(114fn print_code_location(
76	out: &mut impl fmt::Write,115	out: &mut impl fmt::Write,
77	start: &CodeLocation,116	start: &CodeLocation,
78	end: &CodeLocation,117	end: &CodeLocation,
79) -> Result<(), fmt::Error> {118) -> Result<(), fmt::Error> {
119	let end_col = end.column.saturating_sub(1).max(start.column);
80	if start.line == end.line {120	if start.line == end.line {
81		if start.column == end.column {121		if start.column == end_col {
82			write!(out, "{}:{}", start.line, start.column)?;122			write!(out, "{}:{}", start.line, start.column)?;
83		} else {123		} else {
84			write!(124			write!(out, "{}:{}-{}", start.line, start.column, end_col)?;
85				out,
86				"{}:{}-{}",
87				start.line,
88				start.column,
89				end.column.saturating_sub(1)
90			)?;
91		}125		}
92	} else {126	} else {
93		write!(127		write!(
94			out,128			out,
95			"{}:{}-{}:{}",129			"{}:{}-{}:{}",
96			start.line,130			start.line, start.column, end.line, end_col
97			start.column,
98			end.line,
99			end.column.saturating_sub(1)
100		)?;131		)?;
101	}132	}
102	Ok(())133	Ok(())
121152
122impl TraceFormat for CompactFormat {153impl TraceFormat for CompactFormat {
123	fn write_trace(&self, out: &mut dyn fmt::Write, error: &Error) -> Result<(), fmt::Error> {154	fn write_trace(&self, out: &mut dyn fmt::Write, error: &Error) -> Result<(), fmt::Error> {
155		match error.error() {
124		if let ErrorKind::ImportFileNotFound(from, import) = error.error() {156			ErrorKind::ImportFileNotFound(from, import) => {
125			let from = from157				let from = from
126				.path()158					.path()
127				.map_or_else(|| from.to_string(), |path| self.resolver.resolve(path));159					.map_or_else(|| from.to_string(), |path| self.resolver.resolve(path));
130				ResolvePathOwned::Path(path_buf) => self.resolver.resolve(path_buf),162					ResolvePathOwned::Path(path_buf) => self.resolver.resolve(path_buf),
131			};163				};
132			write!(out, "import file not found {import} from {from}")?;164				write!(out, "import file not found {import} from {from}")?;
133		} else {165			}
166			ErrorKind::StaticAnalysisError(_) => {
167				write!(out, "static analysis errors")?;
168			}
169			_ => {
134			write!(out, "{}", error.error())?;170				write!(out, "{}", error.error())?;
135		}171			}
172		}
136173
137		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {174		if let ErrorKind::StaticAnalysisError(diagnostics) = error.error() {
138			use std::fmt::Write;
139
140			writeln!(out)?;
141			let mut n = path.source_path().path().map_or_else(175			let labels: Vec<Option<String>> = diagnostics
176				.iter()
142				|| path.source_path().to_string(),177				.map(|d| d.span.as_ref().map(|s| span_label(&self.resolver, s)))
143				|r| self.resolver.resolve(r),
144			);178				.collect();
145			let offset = (error.location.1 as usize).min(path.code().len());
146			#[expect(clippy::cast_possible_truncation, reason = "code is limited by 4gb")]
147			let location = path179			let align = labels.iter().flatten().map(String::len).max().unwrap_or(0);
148				.map_source_locations(&[offset as u32])
149				.into_iter()
150				.next()
151				.unwrap();
152
153			write!(n, ":").unwrap();180			let cont_indent = " ".repeat(self.padding + align + 1);
154			print_code_location(&mut n, &location, &location).unwrap();181			for (diag, label) in diagnostics.iter().zip(labels.iter()) {
182				writeln!(out)?;
183				let level = diag_level_label(diag.level);
184				let message = diag.message.replace('\n', &format!("\n{cont_indent}"));
185				let label = label.as_deref().unwrap_or("");
155			write!(out, "{:<p$}{n}", "", p = self.padding)?;186				write!(
187					out,
188					"{:<p$}{label:<w$} {level}: {message}",
189					"",
190					p = self.padding,
191					w = align,
192				)?;
193			}
156		}194		}
195
196		if let ErrorKind::ImportSyntaxError { error, .. } = error.error() {
197			writeln!(out)?;
198			let label = span_label(&self.resolver, &error.location);
199			write!(out, "{:<p$}{label}", "", p = self.padding)?;
200		}
157		let file_names = error201		let file_names = error
158			.trace()202			.trace()
159			.0203			.0
160			.iter()204			.iter()
161			.map(|el| &el.location)205			.map(|el| {
162			.map(|location| {206				el.location.as_ref().map(|loc| {
163				use std::fmt::Write;207					use std::fmt::Write;
164				#[allow(clippy::option_if_let_else)]
165				if let Some(location) = location {
166					let mut resolved_path = match location.0.source_path().path() {208					let mut s = span_label(&self.resolver, loc);
167						Some(r) => self.resolver.resolve(r),
168						None => location.0.source_path().to_string(),
169					};
170					// TODO: Process all trace elements first
171					let location = location.0.map_source_locations(&[location.1, location.2]);
172					write!(resolved_path, ":").unwrap();209					write!(s, ":").unwrap();
173					print_code_location(&mut resolved_path, &location[0], &location[1]).unwrap();210					s
174					write!(resolved_path, ":").unwrap();
175					Some(resolved_path)
176				} else {
177					None
178				}
179			})211				})
212			})
180			.collect::<Vec<_>>();213			.collect::<Vec<_>>();
181		let align = file_names214		let align = file_names
182			.iter()215			.iter()
265		}298		}
266		use hi_doc::{Formatting, SnippetBuilder, Text, source_to_ansi};299		use hi_doc::{Formatting, SnippetBuilder, Text, source_to_ansi};
267300
301		match error.error() {
302			ErrorKind::StaticAnalysisError(_) => write!(out, "static analysis errors")?,
268		write!(out, "{}", error.error())?;303			_ => write!(out, "{}", error.error())?,
304		}
269		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {305		if let ErrorKind::ImportSyntaxError { path, error } = error.error() {
270			writeln!(out)?;306			writeln!(out, "\n...at {}", path.source_path())?;
307			if let Some(range) = span_render_range(&error.location) {
271			let mut builder = SnippetBuilder::new(path.code());308				let mut builder = SnippetBuilder::new(path.code());
272			builder309				builder
273				.error(Text::fragment("syntax error", Formatting::default()))310					.error(Text::fragment("syntax error", Formatting::default()))
274				.range(error.location.range())311					.range(range)
275				.build();312					.build();
276			let source = builder.build();313				let ansi = source_to_ansi(&builder.build());
277			let ansi = source_to_ansi(&source);
278			write!(out, "{ansi}")?;314				write!(out, "{}", ansi.trim_end())?;
315			}
279		}316		}
280		if let ErrorKind::StaticAnalysisError(diagnostics) = error.error() {317		if let ErrorKind::StaticAnalysisError(diagnostics) = error.error() {
281			use crate::analyze::DiagLevel;
282			let mut builder: Option<SnippetBuilder> = None;318			let mut builder: Option<(SnippetBuilder, Span)> = None;
283			let mut current_src: Option<&str> = None;
284			let flush = |builder: Option<SnippetBuilder>,319			let flush = |slot: Option<(SnippetBuilder, Span)>,
285			             out: &mut dyn fmt::Write|320			             out: &mut dyn fmt::Write|
286			 -> Result<(), fmt::Error> {321			 -> Result<(), fmt::Error> {
287				if let Some(b) = builder {322				if let Some((b, anchor)) = slot {
323					writeln!(out, "\n...at {}", anchor.0.source_path())?;
288					let ansi = source_to_ansi(&b.build());324					let ansi = source_to_ansi(&b.build());
289					write!(out, "\n{}", ansi.trim_end())?;325					write!(out, "{}", ansi.trim_end())?;
290				}326				}
291				Ok(())327				Ok(())
292			};328			};
293			for diag in diagnostics {329			for diag in diagnostics {
294				if let Some(span) = &diag.span {330				if let Some(span) = &diag.span {
331					let Some(range) = span_render_range(span) else {
332						continue;
333					};
295					let src = span.0.code();334					let same_src = builder.as_ref().is_some_and(|(_, a)| a.0 == span.0);
296					if current_src != Some(src) {335					if !same_src {
297						flush(builder.take(), out)?;336						flush(builder.take(), out)?;
298						builder = Some(SnippetBuilder::new(src));337						builder = Some((SnippetBuilder::new(span.0.code()), span.clone()));
299						current_src = Some(src);
300					}338					}
301					let b = builder.as_mut().unwrap();339					let b = &mut builder.as_mut().unwrap().0;
302					let ab = match diag.level {340					let ab = match diag.level {
303						DiagLevel::Error => {341						DiagLevel::Error => {
304							b.error(Text::fragment(diag.message.clone(), Formatting::default()))342							b.error(Text::fragment(diag.message.clone(), Formatting::default()))
307							b.warning(Text::fragment(diag.message.clone(), Formatting::default()))345							b.warning(Text::fragment(diag.message.clone(), Formatting::default()))
308						}346						}
309					};347					};
310					ab.range(span.range()).build();348					ab.range(range).build();
311				} else {349				} else {
312					flush(builder.take(), out)?;350					flush(builder.take(), out)?;
313					current_src = None;
314					let prefix = match diag.level {351					let prefix = diag_level_label(diag.level);
315						DiagLevel::Error => "error",
316						DiagLevel::Warning => "warning",
317					};
318					write!(out, "\n{prefix}: {}", diag.message)?;352					write!(out, "\n{prefix}: {}", diag.message)?;
319				}353				}
320			}354			}

77		self.offset += 1;77		self.offset += 1;
78	}78	}
7979
80	fn eat_any_spanned(&mut self) -> Span {
81		let start = self.span_start();
82		self.eat_any();
83		let end = self.span_end();
84		Span(self.source.clone(), start, end)
85	}
86
80	fn at_eof(&self) -> bool {87	fn at_eof(&self) -> bool {
81		self.offset >= self.lexemes.len()88		self.offset >= self.lexemes.len()
82	}89	}
114		self.eat_any();121		self.eat_any();
115		Ok(())122		Ok(())
116	}123	}
124	fn eat_spanned(&mut self, t: SyntaxKind) -> Result<Span> {
125		let start = self.span_start();
126		self.eat(t)?;
127		let end = self.span_end();
128		Ok(Span(self.source.clone(), start, end))
129	}
117130
118	fn span_start(&self) -> u32 {131	fn span_start(&self) -> u32 {
119		if self.at_eof() {132		if self.at_eof() {
234	Ok(IStr::from(text))247	Ok(IStr::from(text))
235}248}
236249
237fn literal(p: &mut Parser<'_>) -> Option<LiteralType> {250fn literal(p: &mut Parser<'_>) -> Option<(Span, LiteralType)> {
238	let t = match p.peek() {251	let t = match p.peek() {
239		T![self] => LiteralType::This,252		T![self] => LiteralType::This,
240		T![super] => LiteralType::Super,253		T![super] => LiteralType::Super,
244		T![false] => LiteralType::False,257		T![false] => LiteralType::False,
245		_ => return None,258		_ => return None,
246	};259	};
247	p.eat_any();260	Some((p.eat_any_spanned(), t))
248	Some(t)
249}261}
250262
251fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {263fn assert_stmt(p: &mut Parser<'_>) -> Result<AssertStmt> {
482			});494			});
483		}495		}
484	}496	}
485	let name_spanned = spanned(p, ident)?;497	let name = spanned(p, ident)?;
486	if p.try_eat(T!['(']) {498	if p.try_eat(T!['(']) {
487		let ps = params(p)?;499		let ps = params(p)?;
488		p.eat(T![')'])?;500		p.eat(T![')'])?;
489		p.eat(T![=])?;501		p.eat(T![=])?;
490		Ok(BindSpec::Function {502		Ok(BindSpec::Function {
491			name: name_spanned.value,503			name,
492			params: ps,504			params: ps,
493			value: expr(p)?,505			value: expr(p)?,
494		})506		})
495	} else {507	} else {
496		p.eat(T![=])?;508		p.eat(T![=])?;
497		Ok(BindSpec::Field {509		Ok(BindSpec::Field {
498			into: Destruct::Full(name_spanned),510			into: Destruct::Full(name),
499			value: expr(p)?,511			value: expr(p)?,
500		})512		})
501	}513	}
676688
677#[allow(clippy::too_many_lines)]689#[allow(clippy::too_many_lines)]
678fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {690fn expr_basic(p: &mut Parser<'_>) -> Result<Expr> {
679	if let Some(lit) = literal(p) {691	if let Some((span, lit)) = literal(p) {
680		return Ok(Expr::Literal(lit));692		return Ok(Expr::Literal(span, lit));
681	}693	}
682694
683	match p.peek() {695	match p.peek() {
755		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),767		T![if] => Ok(Expr::IfElse(Box::new(if_else(p)?))),
756768
757		T![function] => {769		T![function] => {
758			p.eat(T![function])?;770			let span = p.eat_spanned(T![function])?;
759			p.eat(T!['('])?;771			p.eat(T!['('])?;
760			let ps = params(p)?;772			let ps = params(p)?;
761			p.eat(T![')'])?;773			p.eat(T![')'])?;
762			let body = expr(p)?;774			let body = expr(p)?;
763			Ok(Expr::Function(ps, Box::new(body)))775			Ok(Expr::Function(span, ps, Box::new(body)))
764		}776		}
765777
766		T![assert] => {778		T![assert] => {
820	if parts.is_empty() {832	if parts.is_empty() {
821		return;833		return;
822	}834	}
823	let old = std::mem::replace(e, Expr::Literal(LiteralType::Null));835	let old = std::mem::replace(e, Expr::Str(IStr::empty()));
824	*e = Expr::Index {836	*e = Expr::Index {
825		indexable: Box::new(old),837		indexable: Box::new(old),
826		parts: std::mem::take(parts),838		parts: std::mem::take(parts),

288		value: Expr,288		value: Expr,
289	},289	},
290	Function {290	Function {
291		name: IStr,291		name: Spanned<IStr>,
292		params: ExprParams,292		params: ExprParams,
293		value: Expr,293		value: Expr,
294	},294	},
404/// Syntax base404/// Syntax base
405#[derive(Debug, PartialEq, Acyclic)]405#[derive(Debug, PartialEq, Acyclic)]
406pub enum Expr {406pub enum Expr {
407	Literal(LiteralType),407	Literal(Span, LiteralType),
408408
409	/// String value: "hello"409	/// String value: "hello"
410	Str(IStr),410	Str(IStr),
454		parts: Vec<IndexPart>,454		parts: Vec<IndexPart>,
455	},455	},
456	/// function(x) x456	/// function(x) x
457	Function(ExprParams, Box<Expr>),457	Function(Span, ExprParams, Box<Expr>),
458	/// if true == false then 1 else 2458	/// if true == false then 1 else 2
459	IfElse(Box<IfElse>),459	IfElse(Box<IfElse>),
460	Slice(Box<Slice>),460	Slice(Box<Slice>),

178}178}
179pub fn visit_expr<V: Visitor>(v: &mut V, e: &Expr) {179pub fn visit_expr<V: Visitor>(v: &mut V, e: &Expr) {
180	match e {180	match e {
181		Expr::Literal(_literal_type) => {}181		Expr::Literal(_span, _literal_type) => {}
182		Expr::Str(_istr) => {}182		Expr::Str(_istr) => {}
183		Expr::Num(_num) => {}183		Expr::Num(_num) => {}
184		Expr::Var(_spanned) => {}184		Expr::Var(_spanned) => {}
254				v.visit_expr(value);254				v.visit_expr(value);
255			}255			}
256		}256		}
257		Expr::Function(expr_params, expr) => {257		Expr::Function(_span, expr_params, expr) => {
258			visit_params(v, expr_params);258			visit_params(v, expr_params);
259			v.visit_expr(expr);259			v.visit_expr(expr);
260		}260		}

131131
132		pub rule bind(s: &ParserSettings) -> BindSpec132		pub rule bind(s: &ParserSettings) -> BindSpec
133			= into:destruct(s) _ "=" _ value:expr(s) {BindSpec::Field{into, value}}133			= into:destruct(s) _ "=" _ value:expr(s) {BindSpec::Field{into, value}}
134			/ name:id() _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {BindSpec::Function{name, params, value}}134			/ name:spanned(<id()>, s) _ "(" _ params:params(s) _ ")" _ "=" _ value:expr(s) {BindSpec::Function{name, params, value}}
135135
136		pub rule assertion(s: &ParserSettings) -> AssertStmt136		pub rule assertion(s: &ParserSettings) -> AssertStmt
137			= keyword("assert") _ assertion:spanned(<expr(s)>, s) message:(_ ":" _ e:expr(s) {e})? { AssertStmt{assertion, message} }137			= keyword("assert") _ assertion:spanned(<expr(s)>, s) message:(_ ":" _ e:expr(s) {e})? { AssertStmt{assertion, message} }
290			}))}290			}))}
291291
292		pub rule literal(s: &ParserSettings) -> Expr292		pub rule literal(s: &ParserSettings) -> Expr
293			= v:(293			= a:position!() v:(
294				keyword("null") {LiteralType::Null}294				keyword("null") {LiteralType::Null}
295				/ keyword("true") {LiteralType::True}295				/ keyword("true") {LiteralType::True}
296				/ keyword("false") {LiteralType::False}296				/ keyword("false") {LiteralType::False}
297				/ keyword("self") {LiteralType::This}297				/ keyword("self") {LiteralType::This}
298				/ keyword("$") {LiteralType::Dollar}298				/ keyword("$") {LiteralType::Dollar}
299				/ keyword("super") {LiteralType::Super}299				/ keyword("super") {LiteralType::Super}
300			) {Expr::Literal(v)}300			) b:position!() {Expr::Literal(Span(s.source.clone(), codeidx(a), codeidx(b)), v)}
301301
302		rule import_kind() -> ImportKind302		rule import_kind() -> ImportKind
303			= keyword("importstr") { ImportKind::Str }303			= keyword("importstr") { ImportKind::Str }
319			/ local_expr(s)319			/ local_expr(s)
320			/ if_then_else_expr(s)320			/ if_then_else_expr(s)
321321
322			/ keyword("function") _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(params, Box::new(expr))}322			/ kw:spanned(<keyword("function")>, s) _ "(" _ params:params(s) _ ")" _ expr:expr(s) {Expr::Function(kw.span, params, Box::new(expr))}
323			/ assert:assertion(s) _ ";" _ rest:expr(s) { Expr::AssertExpr(Box::new(AssertExpr{323			/ assert:assertion(s) _ ";" _ rest:expr(s) { Expr::AssertExpr(Box::new(AssertExpr{
324				assert, rest324				assert, rest
325			})) }325			})) }

1runtime error: foo1runtime error: foo
2    error.03.jsonnet:17:21-25: error statement2    error.03.jsonnet:17:21-25: error statement
3    error.03.jsonnet:18:8-8:   field <x> access3    error.03.jsonnet:18:8:     field <x> access

1runtime error: sarcasm1runtime error: sarcasm
2    error.07.jsonnet:18:31-35: error statement2    error.07.jsonnet:18:31-35: error statement
3    error.07.jsonnet:17:33-33: element <3> access3    error.07.jsonnet:17:33:    element <3> access
4    error.07.jsonnet:18:20-53: function <third> call4    error.07.jsonnet:18:20-53: function <third> call

1static analysis errors: undefined local: foo; undefined local: bar; undefined local: qux1static analysis errors
2    error.args_commafodder.jsonnet:1:1-3 error: undefined local: foo
3    error.args_commafodder.jsonnet:2:3-5 error: undefined local: bar
4    error.args_commafodder.jsonnet:4:7-9 error: undefined local: qux

1static analysis errors: undefined local: x; unused local: x1static analysis errors
2    error.computed_field_scope.jsonnet:17:21 error: undefined local: x
3    error.computed_field_scope.jsonnet:17:9  warning: unused local: x

1no such field: y1no such field: y
2    error.field_not_exist.jsonnet:17:10-10: field <y> access2    error.field_not_exist.jsonnet:17:10: field <y> access

1static analysis errors: local is already defined in the current frame: x; do not define identity functions manually, use std.id instead1static analysis errors
2    error.function_duplicate_param.jsonnet:17:13  error: local is already defined in the current frame: x
3    error.function_duplicate_param.jsonnet:17:1-8 warning: do not define identity functions manually, use std.id instead

1static analysis errors: undefined local: x1static analysis errors
2    lib/static_check_failure.jsonnet:2:1 error: undefined local: x
2    error.import_static-check-failure.jsonnet:1:1-6: import3    error.import_static-check-failure.jsonnet:1:1-6: import

1syntax error: unterminated double-quoted string1syntax error: unterminated double-quoted string
2    lib/syntax_error.jsonnet:1:12    lib/syntax_error.jsonnet:1:1-2:1
3    lib/syntax_error.jsonnet:1:1-2:0:        parse imported3    lib/syntax_error.jsonnet:1:1-2:1:        parse imported
4    error.import_syntax-error.jsonnet:1:1-6: import4    error.import_syntax-error.jsonnet:1:1-6: import

1syntax error: invalid number value: non-finite1syntax error: invalid number value: non-finite
2    error.overflow.jsonnet:17:12    error.overflow.jsonnet:17:1-5
3    error.overflow.jsonnet:17:1-5: parse imported3    error.overflow.jsonnet:17:1-5: parse imported

1syntax error: invalid number value: non-finite1syntax error: invalid number value: non-finite
2    error.overflow3.jsonnet:17:12    error.overflow3.jsonnet:17:1-5
3    error.overflow3.jsonnet:17:1-5: parse imported3    error.overflow3.jsonnet:17:1-5: parse imported

1syntax error: expected ']', got number "3"1syntax error: expected ']', got number "3"
2    error.parse.array_comma.jsonnet:17:72    error.parse.array_comma.jsonnet:17:7
3    error.parse.array_comma.jsonnet:17:7-7: parse imported3    error.parse.array_comma.jsonnet:17:7: parse imported

1syntax error: positional argument after named argument1syntax error: positional argument after named argument
2    error.parse.function_arg_positional_after_named.jsonnet:19:102    error.parse.function_arg_positional_after_named.jsonnet:19:10
3    error.parse.function_arg_positional_after_named.jsonnet:19:10-10: parse imported3    error.parse.function_arg_positional_after_named.jsonnet:19:10: parse imported