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

--- a/bindings/jsonnet/src/import.rs
+++ b/bindings/jsonnet/src/import.rs
@@ -64,7 +64,7 @@
 				self.ctx,
 				base.as_ptr(),
 				rel.as_ptr(),
-				&mut (found_here as *const _),
+				&mut found_here.cast_const(),
 				&mut buf,
 				&mut buf_len,
 			)
@@ -121,7 +121,7 @@
 		cb,
 		ctx,
 		out: RefCell::new(HashMap::new()),
-	})
+	});
 }
 
 /// # Safety

--- a/bindings/jsonnet/src/lib.rs
+++ b/bindings/jsonnet/src/lib.rs
@@ -86,7 +86,6 @@
 	let state = State::default();
 	state.settings_mut().import_resolver = tb!(FileImportResolver::default());
 	state.settings_mut().context_initializer = tb!(jrsonnet_stdlib::ContextInitializer::new(
-		state.clone(),
 		PathResolver::new_cwd_fallback(),
 	));
 	Box::into_raw(Box::new(VM {
@@ -107,7 +106,7 @@
 /// Set the maximum stack depth.
 #[no_mangle]
 pub extern "C" fn jsonnet_max_stack(_vm: &VM, v: c_uint) {
-	set_stack_depth_limit(v as usize)
+	set_stack_depth_limit(v as usize);
 }
 
 /// Set the number of objects required before a garbage collection cycle is allowed.
@@ -175,7 +174,7 @@
 #[no_mangle]
 pub extern "C" fn jsonnet_max_trace(vm: &mut VM, v: c_uint) {
 	if let Some(format) = vm.trace_format.as_any_mut().downcast_mut::<CompactFormat>() {
-		format.max_trace = v as usize
+		format.max_trace = v as usize;
 	} else {
 		panic!("max_trace is not supported by current tracing format")
 	}
@@ -183,7 +182,7 @@
 
 /// Evaluate a file containing Jsonnet code, return a JSON string.
 ///
-/// The returned string should be cleaned up with jsonnet_realloc.
+/// The returned string should be cleaned up with `jsonnet_realloc`.
 ///
 /// # Safety
 ///
@@ -216,7 +215,7 @@
 
 /// Evaluate a string containing Jsonnet code, return a JSON string.
 ///
-/// The returned string should be cleaned up with jsonnet_realloc.
+/// The returned string should be cleaned up with `jsonnet_realloc`.
 ///
 /// # Safety
 ///
@@ -359,7 +358,7 @@
 	out.push(0);
 	let v = out.as_ptr();
 	std::mem::forget(out);
-	v as *const c_char
+	v.cast::<c_char>()
 }
 
 /// # Safety

--- a/bindings/jsonnet/src/val_extract.rs
+++ b/bindings/jsonnet/src/val_extract.rs
@@ -26,7 +26,7 @@
 pub extern "C" fn jsonnet_json_extract_number(_vm: &VM, v: &Val, out: &mut c_double) -> c_int {
 	match v {
 		Val::Num(n) => {
-			*out = *n;
+			*out = n.get();
 			1
 		}
 		_ => 0,

--- a/bindings/jsonnet/src/val_make.rs
+++ b/bindings/jsonnet/src/val_make.rs
@@ -5,7 +5,10 @@
 	os::raw::{c_char, c_double, c_int},
 };
 
-use jrsonnet_evaluator::{val::ArrValue, ObjValue, Val};
+use jrsonnet_evaluator::{
+	val::{ArrValue, NumValue},
+	ObjValue, Val,
+};
 
 use crate::VM;
 
@@ -24,7 +27,9 @@
 /// Convert the given double to a `JsonnetJsonValue`.
 #[no_mangle]
 pub extern "C" fn jsonnet_json_make_number(_vm: &VM, v: c_double) -> *mut Val {
-	Box::into_raw(Box::new(Val::Num(v)))
+	Box::into_raw(Box::new(Val::Num(
+		NumValue::new(v).expect("jsonnet numbers are finite"),
+	)))
 }
 
 /// Convert the given `bool` (`1` or `0`) to a `JsonnetJsonValue`.

--- a/bindings/jsonnet/src/val_modify.rs
+++ b/bindings/jsonnet/src/val_modify.rs
@@ -12,7 +12,7 @@
 ///
 /// # Safety
 ///
-/// `arr` should be a pointer to array value allocated by make_array, or returned by other library call
+/// `arr` should be a pointer to array value allocated by `make_array`, or returned by other library call
 /// `val` should be a pointer to value allocated using this library
 #[no_mangle]
 pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &VM, arr: &mut Val, val: &Val) {

--- a/bindings/jsonnet/src/vars_tlas.rs
+++ b/bindings/jsonnet/src/vars_tlas.rs
@@ -27,7 +27,7 @@
 		.add_ext_str(
 			name.to_str().expect("name is not utf-8").into(),
 			value.to_str().expect("value is not utf-8").into(),
-		)
+		);
 }
 
 /// Binds a Jsonnet external variable to the given code.
@@ -51,7 +51,7 @@
 			name.to_str().expect("name is not utf-8"),
 			code.to_str().expect("code is not utf-8"),
 		)
-		.expect("can't parse ext code")
+		.expect("can't parse ext code");
 }
 
 /// Binds a top-level string argument for a top-level parameter.

--- a/cmds/jrsonnet-fmt/src/children.rs
+++ b/cmds/jrsonnet-fmt/src/children.rs
@@ -28,7 +28,7 @@
 				TS![, ;].contains(item.kind()),
 				"silently eaten token: {:?}",
 				item.kind()
-			)
+			);
 		}
 	}
 	out
@@ -48,13 +48,13 @@
 		if let Some(trivia) = item.as_token().cloned().and_then(Trivia::cast) {
 			out.push(Ok(trivia));
 		} else if CustomError::can_cast(item.kind()) {
-			out.push(Err(item.to_string()))
+			out.push(Err(item.to_string()));
 		} else {
 			assert!(
 				TS![, ;].contains(item.kind()),
 				"silently eaten token: {:?}",
 				item.kind()
-			)
+			);
 		}
 	}
 	out
@@ -115,11 +115,7 @@
 				TriviaKind::Whitespace => {
 					nl_count += t.text().bytes().filter(|b| *b == b'\n').count();
 				}
-				TriviaKind::SingleLineHashComment => {
-					nl_count += 1;
-					break;
-				}
-				TriviaKind::SingleLineSlashComment => {
+				TriviaKind::SingleLineHashComment | TriviaKind::SingleLineSlashComment => {
 					nl_count += 1;
 					break;
 				}
@@ -163,7 +159,7 @@
 				inline_trivia: Vec::new(),
 			});
 			if let Some(last_child) = last_child {
-				out.push(last_child)
+				out.push(last_child);
 			}
 			had_some = true;
 			started_next = false;
@@ -188,7 +184,7 @@
 			}
 			had_some = true;
 		} else if CustomError::can_cast(item.kind()) {
-			next.push(Err(item.to_string()))
+			next.push(Err(item.to_string()));
 		} else if loose {
 			if had_some {
 				break;
@@ -199,7 +195,7 @@
 				TS![, ;].contains(item.kind()),
 				"silently eaten token: {:?}",
 				item.kind()
-			)
+			);
 		}
 	}
 

--- a/cmds/jrsonnet-fmt/src/comments.rs
+++ b/cmds/jrsonnet-fmt/src/comments.rs
@@ -1,3 +1,5 @@
+use std::string::String;
+
 use dprint_core::formatting::PrintItems;
 use jrsonnet_rowan_parser::{nodes::TriviaKind, AstToken};
 
@@ -12,6 +14,7 @@
 	EndOfItems,
 }
 
+#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
 pub fn format_comments(comments: &ChildTrivia, loc: CommentLocation, out: &mut PrintItems) {
 	for c in comments {
 		let Ok(c) = c else {
@@ -62,14 +65,14 @@
 						}
 					})
 					.collect::<Vec<_>>();
-				while lines.last().map(|l| l.is_empty()).unwrap_or(false) {
+				while lines.last().is_some_and(String::is_empty) {
 					lines.pop();
 				}
 				if lines.len() == 1 && !doc {
 					if matches!(loc, CommentLocation::ItemInline) {
 						p!(out, str(" "));
 					}
-					p!(out, str("/* ") string(lines[0].trim().to_string()) str(" */") nl)
+					p!(out, str("/* ") string(lines[0].trim().to_string()) str(" */") nl);
 				} else if !lines.is_empty() {
 					fn common_ws_prefix<'a>(a: &'a str, b: &str) -> &'a str {
 						let offset = a
@@ -95,7 +98,7 @@
 					}
 					for line in lines
 						.iter_mut()
-						.skip(if immediate_start { 1 } else { 0 })
+						.skip(usize::from(immediate_start))
 						.filter(|l| !l.is_empty())
 					{
 						*line = line
@@ -127,13 +130,13 @@
 								}
 								line = new_line.to_string();
 							}
-							p!(out, string(line.to_string()) nl)
+							p!(out, string(line.to_string()) nl);
 						}
 					}
 					if doc {
 						p!(out, str(" "));
 					}
-					p!(out, str("*/") nl)
+					p!(out, str("*/") nl);
 				}
 			}
 			// TODO: Keep common padding for multiple continous lines of single-line comments
@@ -154,20 +157,20 @@
 			// ```
 			TriviaKind::SingleLineHashComment => {
 				if matches!(loc, CommentLocation::ItemInline) {
-					p!(out, str(" "))
+					p!(out, str(" "));
 				}
 				p!(out, str("# ") string(c.text().strip_prefix('#').expect("hash comment starts with #").trim().to_string()));
 				if !matches!(loc, CommentLocation::ItemInline) {
-					p!(out, nl)
+					p!(out, nl);
 				}
 			}
 			TriviaKind::SingleLineSlashComment => {
 				if matches!(loc, CommentLocation::ItemInline) {
-					p!(out, str(" "))
+					p!(out, str(" "));
 				}
 				p!(out, str("// ") string(c.text().strip_prefix("//").expect("comment starts with //").trim().to_string()));
 				if !matches!(loc, CommentLocation::ItemInline) {
-					p!(out, nl)
+					p!(out, nl);
 				}
 			}
 			// Garbage in - garbage out

--- a/cmds/jrsonnet-fmt/src/main.rs
+++ b/cmds/jrsonnet-fmt/src/main.rs
@@ -13,6 +13,7 @@
 	condition_helpers::is_multiple_lines, condition_resolvers::true_resolver,
 	ConditionResolverContext, LineNumber, PrintItems, PrintOptions,
 };
+use hi_doc::Formatting;
 use jrsonnet_rowan_parser::{
 	nodes::{
 		Arg, ArgsDesc, Assertion, BinaryOperator, Bind, CompSpec, Destruct, DestructArrayPart,
@@ -155,7 +156,7 @@
 {
 	fn print(&self, out: &mut PrintItems) {
 		if let Some(v) = self {
-			v.print(out)
+			v.print(out);
 		} else {
 			p!(
 				out,
@@ -163,31 +164,31 @@
 					"/*missing {}*/",
 					type_name::<P>().replace("jrsonnet_rowan_parser::generated::nodes::", "")
 				),)
-			)
+			);
 		}
 	}
 }
 
 impl Printable for SyntaxToken {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.to_string()))
+		p!(out, string(self.to_string()));
 	}
 }
 
 impl Printable for Text {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(format!("{}", self)))
+		p!(out, string(format!("{}", self)));
 	}
 }
 impl Printable for Number {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(format!("{}", self)))
+		p!(out, string(format!("{}", self)));
 	}
 }
 
 impl Printable for Name {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, { self.ident_lit() })
+		p!(out, { self.ident_lit() });
 	}
 }
 
@@ -203,30 +204,30 @@
 impl Printable for Destruct {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			Destruct::DestructFull(f) => {
-				p!(out, { f.name() })
+			Self::DestructFull(f) => {
+				p!(out, { f.name() });
 			}
-			Destruct::DestructSkip(_) => p!(out, str("?")),
-			Destruct::DestructArray(a) => {
+			Self::DestructSkip(_) => p!(out, str("?")),
+			Self::DestructArray(a) => {
 				p!(out, str("[") >i nl);
 				for el in a.destruct_array_parts() {
 					match el {
 						DestructArrayPart::DestructArrayElement(e) => {
-							p!(out, {e.destruct()} str(",") nl)
+							p!(out, {e.destruct()} str(",") nl);
 						}
 						DestructArrayPart::DestructRest(d) => {
-							p!(out, {d} str(",") nl)
+							p!(out, {d} str(",") nl);
 						}
 					}
 				}
 				p!(out, <i str("]"));
 			}
-			Destruct::DestructObject(o) => {
+			Self::DestructObject(o) => {
 				p!(out, str("{") >i nl);
 				for item in o.destruct_object_fields() {
 					p!(out, { item.field() });
 					if let Some(des) = item.destruct() {
-						p!(out, str(": ") {des})
+						p!(out, str(": ") {des});
 					}
 					if let Some(def) = item.expr() {
 						p!(out, str(" = ") {def});
@@ -234,7 +235,7 @@
 					p!(out, str(",") nl);
 				}
 				if let Some(rest) = o.destruct_rest() {
-					p!(out, {rest} nl)
+					p!(out, {rest} nl);
 				}
 				p!(out, <i str("}"));
 			}
@@ -245,17 +246,17 @@
 impl Printable for FieldName {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			FieldName::FieldNameFixed(f) => {
+			Self::FieldNameFixed(f) => {
 				if let Some(id) = f.id() {
-					p!(out, { id })
+					p!(out, { id });
 				} else if let Some(str) = f.text() {
-					p!(out, { str })
+					p!(out, { str });
 				} else {
-					p!(out, str("/*missing FieldName*/"))
+					p!(out, str("/*missing FieldName*/"));
 				}
 			}
-			FieldName::FieldNameDynamic(d) => {
-				p!(out, str("[") {d.expr()} str("]"))
+			Self::FieldNameDynamic(d) => {
+				p!(out, str("[") {d.expr()} str("]"));
 			}
 		}
 	}
@@ -263,13 +264,13 @@
 
 impl Printable for Visibility {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.to_string()))
+		p!(out, string(self.to_string()));
 	}
 }
 
 impl Printable for ObjLocal {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, str("local ") {self.bind()})
+		p!(out, str("local ") {self.bind()});
 	}
 }
 
@@ -277,7 +278,7 @@
 	fn print(&self, out: &mut PrintItems) {
 		p!(out, str("assert ") {self.condition()});
 		if self.colon_token().is_some() || self.message().is_some() {
-			p!(out, str(": ") {self.message()})
+			p!(out, str(": ") {self.message()});
 		}
 	}
 }
@@ -288,9 +289,9 @@
 		for param in self.params() {
 			p!(out, { param.destruct() });
 			if param.assign_token().is_some() || param.expr().is_some() {
-				p!(out, str(" = ") {param.expr()})
+				p!(out, str(" = ") {param.expr()});
 			}
-			p!(out, str(",") nl)
+			p!(out, str(",") nl);
 		}
 		p!(out, <i str(")"));
 	}
@@ -343,7 +344,7 @@
 		}
 		p!(out, str(":"));
 		if self.end().is_some() {
-			p!(out, { self.end().map(|e| e.expr()) })
+			p!(out, { self.end().map(|e| e.expr()) });
 		}
 		// Keep only one : in case if we don't need step
 		if self.step().is_some() {
@@ -357,16 +358,16 @@
 	fn print(&self, out: &mut PrintItems) {
 		match self {
 			Self::MemberBindStmt(b) => {
-				p!(out, { b.obj_local() })
+				p!(out, { b.obj_local() });
 			}
 			Self::MemberAssertStmt(ass) => {
-				p!(out, { ass.assertion() })
+				p!(out, { ass.assertion() });
 			}
 			Self::MemberFieldNormal(n) => {
-				p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()})
+				p!(out, {n.field_name()} if(n.plus_token().is_some())({n.plus_token()}) {n.visibility()} str(" ") {n.expr()});
 			}
 			Self::MemberFieldMethod(m) => {
-				p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()})
+				p!(out, {m.field_name()} {m.params_desc()} {m.visibility()} str(" ") {m.expr()});
 			}
 		}
 	}
@@ -375,7 +376,7 @@
 impl Printable for ObjBody {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			ObjBody::ObjBodyComp(l) => {
+			Self::ObjBodyComp(l) => {
 				let (children, mut end_comments) = children_between::<Member>(
 					l.syntax().clone(),
 					l.l_brace_token().map(Into::into).as_ref(),
@@ -391,14 +392,14 @@
 				);
 				let trailing_for_comp = end_comments.extract_trailing();
 				p!(out, str("{") >i nl);
-				for mem in children.into_iter() {
+				for mem in children {
 					if mem.should_start_with_newline {
 						p!(out, nl);
 					}
 					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);
 					p!(out, {mem.value} str(","));
 					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);
-					p!(out, nl)
+					p!(out, nl);
 				}
 
 				if end_comments.should_start_with_newline {
@@ -417,7 +418,7 @@
 					l.r_brace_token().map(Into::into).as_ref(),
 					Some(trailing_for_comp),
 				);
-				for mem in compspecs.into_iter() {
+				for mem in compspecs {
 					if mem.should_start_with_newline {
 						p!(out, nl);
 					}
@@ -432,7 +433,7 @@
 
 				p!(out, nl <i str("}"));
 			}
-			ObjBody::ObjBodyMemberList(l) => {
+			Self::ObjBodyMemberList(l) => {
 				let (children, end_comments) = children_between::<Member>(
 					l.syntax().clone(),
 					l.l_brace_token().map(Into::into).as_ref(),
@@ -451,7 +452,7 @@
 					format_comments(&mem.before_trivia, CommentLocation::AboveItem, out);
 					p!(out, {mem.value} str(","));
 					format_comments(&mem.inline_trivia, CommentLocation::ItemInline, out);
-					p!(out, nl)
+					p!(out, nl);
 				}
 
 				if end_comments.should_start_with_newline {
@@ -465,51 +466,51 @@
 }
 impl Printable for UnaryOperator {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.text().to_string()))
+		p!(out, string(self.text().to_string()));
 	}
 }
 impl Printable for BinaryOperator {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.text().to_string()))
+		p!(out, string(self.text().to_string()));
 	}
 }
 impl Printable for Bind {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			Bind::BindDestruct(d) => {
-				p!(out, {d.into()} str(" = ") {d.value()})
+			Self::BindDestruct(d) => {
+				p!(out, {d.into()} str(" = ") {d.value()});
 			}
-			Bind::BindFunction(f) => {
-				p!(out, {f.name()} {f.params()} str(" = ") {f.value()})
+			Self::BindFunction(f) => {
+				p!(out, {f.name()} {f.params()} str(" = ") {f.value()});
 			}
 		}
 	}
 }
 impl Printable for Literal {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.syntax().to_string()))
+		p!(out, string(self.syntax().to_string()));
 	}
 }
 impl Printable for ImportKind {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, string(self.syntax().to_string()))
+		p!(out, string(self.syntax().to_string()));
 	}
 }
 impl Printable for ForSpec {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, str("for ") {self.bind()} str(" in ") {self.expr()})
+		p!(out, str("for ") {self.bind()} str(" in ") {self.expr()});
 	}
 }
 impl Printable for IfSpec {
 	fn print(&self, out: &mut PrintItems) {
-		p!(out, str("if ") {self.expr()})
+		p!(out, str("if ") {self.expr()});
 	}
 }
 impl Printable for CompSpec {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			CompSpec::ForSpec(f) => f.print(out),
-			CompSpec::IfSpec(i) => i.print(out),
+			Self::ForSpec(f) => f.print(out),
+			Self::IfSpec(i) => i.print(out),
 		}
 	}
 }
@@ -549,23 +550,23 @@
 impl Printable for Suffix {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			Suffix::SuffixIndex(i) => {
+			Self::SuffixIndex(i) => {
 				if i.question_mark_token().is_some() {
 					p!(out, str("?"));
 				}
 				p!(out, str(".") {i.index()});
 			}
-			Suffix::SuffixIndexExpr(e) => {
+			Self::SuffixIndexExpr(e) => {
 				if e.question_mark_token().is_some() {
 					p!(out, str(".?"));
 				}
-				p!(out, str("[") {e.index()} str("]"))
+				p!(out, str("[") {e.index()} str("]"));
 			}
-			Suffix::SuffixSlice(d) => {
-				p!(out, { d.slice_desc() })
+			Self::SuffixSlice(d) => {
+				p!(out, { d.slice_desc() });
 			}
-			Suffix::SuffixApply(a) => {
-				p!(out, { a.args_desc() })
+			Self::SuffixApply(a) => {
+				p!(out, { a.args_desc() });
 			}
 		}
 	}
@@ -573,7 +574,7 @@
 impl Printable for Stmt {
 	fn print(&self, out: &mut PrintItems) {
 		match self {
-			Stmt::StmtLocal(l) => {
+			Self::StmtLocal(l) => {
 				let (binds, end_comments) = children_between::<Bind>(
 					l.syntax().clone(),
 					l.local_kw_token().map(Into::into).as_ref(),
@@ -594,18 +595,18 @@
 						format_comments(&bind.before_trivia, CommentLocation::AboveItem, out);
 						p!(out, {bind.value} str(","));
 						format_comments(&bind.inline_trivia, CommentLocation::ItemInline, out);
-						p!(out, nl)
+						p!(out, nl);
 					}
 					if end_comments.should_start_with_newline {
-						p!(out, nl)
+						p!(out, nl);
 					}
 					format_comments(&end_comments.trivia, CommentLocation::EndOfItems, out);
 					p!(out,<i);
 				}
 				p!(out,str(";") nl);
 			}
-			Stmt::StmtAssert(a) => {
-				p!(out, {a.assertion()} str(";") nl)
+			Self::StmtAssert(a) => {
+				p!(out, {a.assertion()} str(";") nl);
 			}
 		}
 	}
@@ -614,7 +615,7 @@
 	fn print(&self, out: &mut PrintItems) {
 		match self {
 			Self::ExprBinary(b) => {
-				p!(out, {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()})
+				p!(out, {b.lhs_work()} str(" ") {b.binary_operator()} str(" ") {b.rhs_work()});
 			}
 			Self::ExprUnary(u) => p!(out, {u.unary_operator()} {u.rhs()}),
 			// Self::ExprSlice(s) => {
@@ -632,10 +633,10 @@
 			// 	pi
 			// }
 			Self::ExprObjExtend(ex) => {
-				p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()})
+				p!(out, {ex.lhs_work()} str(" ") {ex.rhs_work()});
 			}
 			Self::ExprParened(p) => {
-				p!(out, str("(") {p.expr()} str(")"))
+				p!(out, str("(") {p.expr()} str(")"));
 			}
 			Self::ExprString(s) => p!(out, { s.text() }),
 			Self::ExprNumber(n) => p!(out, { n.number() }),
@@ -647,7 +648,7 @@
 				p!(out, <i str("]"));
 			}
 			Self::ExprObject(obj) => {
-				p!(out, { obj.obj_body() })
+				p!(out, { obj.obj_body() });
 			}
 			Self::ExprArrayComp(arr) => {
 				p!(out, str("[") {arr.expr()});
@@ -657,7 +658,7 @@
 				p!(out, str("]"));
 			}
 			Self::ExprImport(v) => {
-				p!(out, {v.import_kind()} str(" ") {v.text()})
+				p!(out, {v.import_kind()} str(" ") {v.text()});
 			}
 			Self::ExprVar(n) => p!(out, { n.name() }),
 			// Self::ExprLocal(l) => {
@@ -665,14 +666,14 @@
 			Self::ExprIfThenElse(ite) => {
 				p!(out, str("if ") {ite.cond()} str(" then ") {ite.then().map(|t| t.expr())});
 				if ite.else_kw_token().is_some() || ite.else_().is_some() {
-					p!(out, str(" else ") {ite.else_().map(|t| t.expr())})
+					p!(out, str(" else ") {ite.else_().map(|t| t.expr())});
 				}
 			}
 			Self::ExprFunction(f) => p!(out, str("function") {f.params_desc()} nl {f.expr()}),
 			// Self::ExprAssert(a) => p!(new: {a.assertion()} str("; ") {a.expr()}),
 			Self::ExprError(e) => p!(out, str("error ") {e.expr()}),
 			Self::ExprLiteral(l) => {
-				p!(out, { l.literal() })
+				p!(out, { l.literal() });
 			}
 		}
 	}
@@ -696,7 +697,7 @@
 		);
 		format_comments(&before, CommentLocation::AboveItem, out);
 		p!(out, {self.expr()} nl);
-		format_comments(&after, CommentLocation::EndOfItems, out)
+		format_comments(&after, CommentLocation::EndOfItems, out);
 	}
 }
 
@@ -712,7 +713,7 @@
 			builder
 				.error(hi_doc::Text::single(
 					format!("{:?}", error.error).chars(),
-					Default::default(),
+					Formatting::default(),
 				))
 				.range(
 					error.range.start().into()
@@ -751,6 +752,7 @@
 }
 
 #[derive(Parser)]
+#[allow(clippy::struct_excessive_bools)]
 struct Opts {
 	/// Treat input as code, reformat it instead of reading file.
 	#[clap(long, short = 'e')]
@@ -814,7 +816,7 @@
 
 	let mut iteration = 0;
 	let mut formatted = input.clone();
-	let mut tmp;
+	let mut convergence_tmp;
 	// https://github.com/dprint/dprint/pull/423
 	loop {
 		let Some(reformatted) = format(
@@ -829,18 +831,16 @@
 		) else {
 			return Err(Error::Parse);
 		};
-		tmp = reformatted.trim().to_owned();
-		if formatted == tmp {
+		convergence_tmp = reformatted.trim().to_owned();
+		if formatted == convergence_tmp {
 			break;
 		}
-		formatted = tmp;
+		formatted = convergence_tmp;
 		if opts.conv_limit == 0 {
 			break;
 		}
 		iteration += 1;
-		if iteration > opts.conv_limit {
-			panic!("formatting not converged");
-		}
+		assert!(iteration <= opts.conv_limit, "formatting not converged");
 	}
 	formatted.push('\n');
 	if opts.test && formatted != input {
@@ -855,7 +855,7 @@
 		temp.flush()?;
 		temp.persist(&path)?;
 	} else {
-		print!("{formatted}")
+		print!("{formatted}");
 	}
 	Ok(())
 }

--- a/crates/jrsonnet-rowan-parser/src/lex.rs
+++ b/crates/jrsonnet-rowan-parser/src/lex.rs
@@ -37,9 +37,10 @@
 			// In kinds, string blocks is parsed at least as `|||`
 			lexer.bump(3);
 			let res = lex_str_block(&mut lexer);
-			debug_assert!(lexer.next().is_none(), "str_block is lexed");
+			let next = lexer.next();
+			assert!(next.is_none(), "str_block is lexed");
 			match res {
-				Ok(_) => {}
+				Ok(()) => {}
 				Err(e) => {
 					kind = Ok(match e {
 						StringBlockError::UnexpectedEnd => ERROR_STRING_BLOCK_UNEXPECTED_END,
@@ -48,7 +49,7 @@
 							ERROR_STRING_BLOCK_MISSING_TERMINATION
 						}
 						StringBlockError::MissingIndent => ERROR_STRING_BLOCK_MISSING_INDENT,
-					})
+					});
 				}
 			}
 		}

--- a/crates/jrsonnet-rowan-parser/src/marker.rs
+++ b/crates/jrsonnet-rowan-parser/src/marker.rs
@@ -146,7 +146,7 @@
 		p: &mut Parser,
 		kind: SyntaxKind,
 		error: Option<SyntaxError>,
-	) -> CompletedMarker {
+	) -> Self {
 		let new_m = p.start();
 		match &mut p.events[self.start_event_idx] {
 			Event::Start { forward_parent, .. } => {
@@ -173,10 +173,10 @@
 		}
 		completed
 	}
-	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
+	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> Self {
 		self.wrap_raw(p, kind, None)
 	}
-	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {
+	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> Self {
 		self.wrap_raw(
 			p,
 			SyntaxKind::ERROR_CUSTOM,