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,
-					})
+					});
 				}
 			}
 		}

146		p: &mut Parser,146		p: &mut Parser,
147		kind: SyntaxKind,147		kind: SyntaxKind,
148		error: Option<SyntaxError>,148		error: Option<SyntaxError>,
149	) -> CompletedMarker {149	) -> Self {
150		let new_m = p.start();150		let new_m = p.start();
151		match &mut p.events[self.start_event_idx] {151		match &mut p.events[self.start_event_idx] {
152			Event::Start { forward_parent, .. } => {152			Event::Start { forward_parent, .. } => {
173		}173		}
174		completed174		completed
175	}175	}
176	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {176	pub fn wrap(self, p: &mut Parser, kind: SyntaxKind) -> Self {
177		self.wrap_raw(p, kind, None)177		self.wrap_raw(p, kind, None)
178	}178	}
179	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> CompletedMarker {179	pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef<str>) -> Self {
180		self.wrap_raw(180		self.wrap_raw(
181			p,181			p,
182			SyntaxKind::ERROR_CUSTOM,182			SyntaxKind::ERROR_CUSTOM,

--- a/crates/jrsonnet-rowan-parser/src/parser.rs
+++ b/crates/jrsonnet-rowan-parser/src/parser.rs
@@ -72,9 +72,9 @@
 			.rev()
 			.take_while(|h| h.0 > self.entered)
 			.count();
-		self.hints.truncate(self.hints.len() - amount)
+		self.hints.truncate(self.hints.len() - amount);
 	}
-	fn clear_expected_syntaxes(&mut self) {
+	fn clear_expected_syntaxes(&self) {
 		self.expected_syntax_tracking_state
 			.set(ExpectedSyntax::Unnamed(TS![]));
 	}
@@ -104,7 +104,7 @@
 	}
 
 	pub(crate) fn expect(&mut self, kind: SyntaxKind) {
-		self.expect_with_recovery_set(kind, TS![])
+		self.expect_with_recovery_set(kind, TS![]);
 	}
 
 	pub(crate) fn expect_with_recovery_set(
@@ -153,7 +153,7 @@
 		m
 	}
 	fn bump_assert(&mut self, kind: SyntaxKind) {
-		assert!(self.at(kind), "expected {:?}", kind);
+		assert!(self.at(kind), "expected {kind:?}");
 		self.bump_remap(self.current());
 	}
 	fn bump(&mut self) {
@@ -168,11 +168,11 @@
 	fn step(&self) {
 		use std::fmt::Write;
 		let steps = self.steps.get();
-		if steps >= 15000000 {
+		if steps >= 15_000_000 {
 			let mut out = "seems like parsing is stuck".to_owned();
 			{
 				let last = 20;
-				write!(out, "\n\nLast {} events:", last).unwrap();
+				write!(out, "\n\nLast {last} events:").unwrap();
 				for (i, event) in self
 					.events
 					.iter()
@@ -205,38 +205,38 @@
 		self.nth(0)
 	}
 	#[must_use]
-	pub(crate) fn expected_syntax_name(&mut self, name: &'static str) -> ExpectedSyntaxGuard {
+	pub(crate) fn expected_syntax_name(&self, name: &'static str) -> ExpectedSyntaxGuard {
 		self.expected_syntax_tracking_state
 			.set(ExpectedSyntax::Named(name));
 
 		ExpectedSyntaxGuard::new(Rc::clone(&self.expected_syntax_tracking_state))
 	}
-	pub fn at(&mut self, kind: SyntaxKind) -> bool {
+	pub fn at(&self, kind: SyntaxKind) -> bool {
 		self.nth_at(0, kind)
 	}
-	pub fn nth_at(&mut self, n: usize, kind: SyntaxKind) -> bool {
+	pub fn nth_at(&self, n: usize, kind: SyntaxKind) -> bool {
 		if n == 0 {
 			if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
 				let kinds = kinds.with(kind);
 				self.expected_syntax_tracking_state
-					.set(ExpectedSyntax::Unnamed(kinds))
+					.set(ExpectedSyntax::Unnamed(kinds));
 			}
 		}
 		self.nth(n) == kind
 	}
-	pub fn at_ts(&mut self, set: SyntaxKindSet) -> bool {
+	pub fn at_ts(&self, set: SyntaxKindSet) -> bool {
 		if let ExpectedSyntax::Unnamed(kinds) = self.expected_syntax_tracking_state.get() {
 			let kinds = kinds.union(set);
 			self.expected_syntax_tracking_state
-				.set(ExpectedSyntax::Unnamed(kinds))
+				.set(ExpectedSyntax::Unnamed(kinds));
 		}
 		set.contains(self.current())
 	}
-	pub fn at_end(&mut self) -> bool {
+	pub fn at_end(&self) -> bool {
 		self.at(EOF)
 	}
 }
-pub(crate) struct ExpectedSyntaxGuard {
+pub struct ExpectedSyntaxGuard {
 	expected_syntax_tracking_state: Rc<Cell<ExpectedSyntax>>,
 }
 
@@ -263,8 +263,8 @@
 impl fmt::Display for ExpectedSyntax {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 		match self {
-			ExpectedSyntax::Named(name) => write!(f, "{name}"),
-			ExpectedSyntax::Unnamed(set) => write!(f, "{set}"),
+			Self::Named(name) => write!(f, "{name}"),
+			Self::Unnamed(set) => write!(f, "{set}"),
 		}
 	}
 }
@@ -298,8 +298,7 @@
 		}
 	}
 	match expr_binding_power(p, 0) {
-		Ok(m) => m,
-		Err(m) => m,
+		Ok(m) | Err(m) => m,
 	};
 	m.complete(p, EXPR)
 }
@@ -399,7 +398,7 @@
 }
 fn visibility(p: &mut Parser) {
 	if p.at_ts(TS![: :: :::]) {
-		p.bump()
+		p.bump();
 	} else {
 		p.error_with_recovery_set(TS![=]);
 	}
@@ -556,7 +555,7 @@
 			expr(p);
 			let arg = m.complete(p, ARG);
 			if started_named.get() {
-				unnamed_after_named.push(arg)
+				unnamed_after_named.push(arg);
 			}
 		}
 		if comma(p) {
@@ -566,7 +565,7 @@
 	}
 	p.expect(T![')']);
 	if p.at(T![tailstrict]) {
-		p.bump()
+		p.bump();
 	}
 
 	for errored in unnamed_after_named {
@@ -719,7 +718,7 @@
 	let m = p.start();
 	p.bump_assert(T![...]);
 	if p.at(IDENT) {
-		p.bump()
+		p.bump();
 	}
 	m.complete(p, DESTRUCT_REST);
 }

--- a/crates/jrsonnet-rowan-parser/src/precedence.rs
+++ b/crates/jrsonnet-rowan-parser/src/precedence.rs
@@ -13,8 +13,7 @@
 			Self::BitXor => (8, 9),
 			Self::BitOr => (6, 7),
 			Self::And => (4, 5),
-			Self::NullCoaelse => (2, 3),
-			Self::Or => (2, 3),
+			Self::NullCoaelse | Self::Or => (2, 3),
 			Self::ErrorNoOperator => (0, 1),
 		}
 	}
@@ -23,9 +22,7 @@
 impl UnaryOperatorKind {
 	pub fn binding_power(&self) -> ((), u8) {
 		match self {
-			Self::Minus => ((), 20),
-			Self::Not => ((), 20),
-			Self::BitNot => ((), 20),
+			Self::Minus | Self::Not | Self::BitNot => ((), 20),
 		}
 	}
 }

--- a/crates/jrsonnet-rowan-parser/src/string_block.rs
+++ b/crates/jrsonnet-rowan-parser/src/string_block.rs
@@ -17,6 +17,7 @@
 	let _ = lex_str_block(lex);
 }
 
+#[allow(clippy::too_many_lines)]
 pub fn lex_str_block(lex: &mut Lexer<SyntaxKind>) -> Result<(), StringBlockError> {
 	struct Context<'a> {
 		source: &'a str,
@@ -78,6 +79,7 @@
 			};
 		}
 
+		#[allow(clippy::range_plus_one)]
 		fn pos(&self) -> Range<usize> {
 			if self.index == self.source.len() {
 				self.offset + self.index..self.offset + self.index
@@ -120,8 +122,7 @@
 		let end_index = ctx
 			.rest()
 			.find("|||")
-			.map(|v| v + 3)
-			.unwrap_or_else(|| ctx.rest().len());
+			.map_or_else(|| ctx.rest().len(), |v| v + 3);
 		lex.bump(ctx.index + end_index);
 	}
 
@@ -150,7 +151,7 @@
 	}
 
 	// Process leading blank lines before calculating string block indent
-	while let Some('\n') = ctx.peek() {
+	while ctx.peek() == Some('\n') {
 		ctx.next();
 	}
 
@@ -179,7 +180,7 @@
 		}
 
 		// Skip any blank lines
-		while let Some('\n') = ctx.peek() {
+		while ctx.peek() == Some('\n') {
 			ctx.next();
 		}
 
@@ -187,9 +188,11 @@
 		num_whitespace = check_whitespace(str_block_indent, ctx.rest());
 		if num_whitespace == 0 {
 			// End of the text block
-			let mut term_indent = String::with_capacity(num_whitespace);
+			// let mut term_indent = String::with_capacity(num_whitespace);
 			while let Some(' ' | '\t') = ctx.peek() {
-				term_indent.push(ctx.next().unwrap());
+				// term_indent.push(
+				ctx.next().unwrap();
+				// );
 			}
 
 			if !ctx.rest().starts_with("|||") {

--- a/crates/jrsonnet-rowan-parser/src/token_set.rs
+++ b/crates/jrsonnet-rowan-parser/src/token_set.rs
@@ -10,21 +10,23 @@
 	pub const EMPTY: Self = Self(0);
 	pub const ALL: Self = Self(u128::MAX);
 
-	pub const fn new(kinds: &[SyntaxKind]) -> SyntaxKindSet {
+	pub const fn new(kinds: &[SyntaxKind]) -> Self {
 		let mut res = 0u128;
 		let mut i = 0;
 		while i < kinds.len() {
 			res |= mask(kinds[i]);
-			i += 1
+			i += 1;
 		}
-		SyntaxKindSet(res)
+		Self(res)
 	}
 
-	pub const fn union(self, other: SyntaxKindSet) -> SyntaxKindSet {
-		SyntaxKindSet(self.0 | other.0)
+	#[must_use]
+	pub const fn union(self, other: Self) -> Self {
+		Self(self.0 | other.0)
 	}
-	pub const fn with(self, kind: SyntaxKind) -> SyntaxKindSet {
-		SyntaxKindSet(self.0 | mask(kind))
+	#[must_use]
+	pub const fn with(self, kind: SyntaxKind) -> Self {
+		Self(self.0 | mask(kind))
 	}
 
 	pub fn contains(&self, kind: SyntaxKind) -> bool {
@@ -40,7 +42,7 @@
 		let mut variants = <Vec<SyntaxKind>>::new();
 		for i in 0..128 {
 			if v & 1 == 1 {
-				variants.push(SyntaxKind::from_raw(i))
+				variants.push(SyntaxKind::from_raw(i));
 			}
 			v >>= 1;
 			if v == 0 {
@@ -65,7 +67,7 @@
 		let mut variants = <Vec<SyntaxKind>>::new();
 		for i in 0..128 {
 			if v & 1 == 1 {
-				variants.push(SyntaxKind::from_raw(i))
+				variants.push(SyntaxKind::from_raw(i));
 			}
 			v >>= 1;
 			if v == 0 {
@@ -77,9 +79,7 @@
 }
 
 const fn mask(kind: SyntaxKind) -> u128 {
-	if kind as u32 > 128 {
-		panic!("mask for not a token kind")
-	}
+	assert!(kind as u32 <= 128, "mask for not a token kind");
 	1u128 << (kind as u128)
 }
 

--- a/xtask/src/sourcegen/ast.rs
+++ b/xtask/src/sourcegen/ast.rs
@@ -72,7 +72,7 @@
 	pub fn is_many(&self) -> bool {
 		matches!(
 			self,
-			Field::Node {
+			Self::Node {
 				cardinality: Cardinality::Many,
 				..
 			}
@@ -81,44 +81,41 @@
 
 	pub fn token_name(&self) -> Option<String> {
 		match self {
-			Field::Token(token) => Some(token.clone()),
-			_ => None,
+			Self::Token(token) => Some(token.clone()),
+			Self::Node { .. } => None,
 		}
 	}
 	pub fn token_kind(&self, kinds: &KindsSrc) -> Option<TokenStream> {
 		match self {
-			Field::Token(token) => Some(kinds.token(token).expect("token exists").reference()),
-			_ => None,
+			Self::Token(token) => Some(kinds.token(token).expect("token exists").reference()),
+			Self::Node { .. } => None,
 		}
 	}
 	pub fn is_token_enum(&self, grammar: &AstSrc) -> bool {
 		match self {
-			Field::Node { ty, .. } => grammar.token_enums.iter().any(|e| &e.name == ty),
-			_ => false,
+			Self::Node { ty, .. } => grammar.token_enums.iter().any(|e| &e.name == ty),
+			Self::Token(_) => false,
 		}
 	}
 
 	pub fn method_name(&self, kinds: &KindsSrc) -> proc_macro2::Ident {
 		match self {
-			Field::Token(name) => kinds.token(name).expect("token exists").method_name(),
-			Field::Node { name, .. } => {
+			Self::Token(name) => kinds.token(name).expect("token exists").method_name(),
+			Self::Node { name, .. } => {
 				format_ident!("{}", name)
 			}
 		}
 	}
 	pub fn ty(&self) -> proc_macro2::Ident {
 		match self {
-			Field::Token(_) => format_ident!("SyntaxToken"),
-			Field::Node { ty, .. } => format_ident!("{}", ty),
+			Self::Token(_) => format_ident!("SyntaxToken"),
+			Self::Node { ty, .. } => format_ident!("{}", ty),
 		}
 	}
 }
 
 pub fn lower(kinds: &KindsSrc, grammar: &Grammar) -> AstSrc {
-	let mut res = AstSrc {
-		// tokens,
-		..Default::default()
-	};
+	let mut res = AstSrc::default();
 
 	let nodes = grammar.iter().collect::<Vec<_>>();
 
@@ -135,16 +132,15 @@
 				};
 				res.enums.push(enum_src);
 			}
-			None => match lower_token_enum(grammar, rule) {
-				Some(variants) => {
+			None => {
+				if let Some(variants) = lower_token_enum(grammar, rule) {
 					let tokens_enum_src = AstTokenEnumSrc {
 						doc: Vec::new(),
 						name,
 						variants,
 					};
 					res.token_enums.push(tokens_enum_src);
-				}
-				None => {
+				} else {
 					let mut fields = Vec::new();
 					lower_rule(&mut fields, grammar, None, rule, false);
 					let mut types = HashMap::new();
@@ -173,7 +169,7 @@
 						fields,
 					});
 				}
-			},
+			}
 		}
 	}
 
@@ -240,7 +236,7 @@
 			acc.push(field);
 		}
 		Rule::Token(token) => {
-			assert!(label.is_none(), "uexpected label: {:?}", label);
+			assert!(label.is_none(), "uexpected label: {label:?}");
 			let name = grammar[*token].name.clone();
 			let field = Field::Token(name);
 			acc.push(field);
@@ -267,7 +263,7 @@
 		}
 		Rule::Seq(rules) | Rule::Alt(rules) => {
 			for rule in rules {
-				lower_rule(acc, grammar, label, rule, in_optional)
+				lower_rule(acc, grammar, label, rule, in_optional);
 			}
 		}
 		Rule::Opt(rule) => lower_rule(acc, grammar, label, rule, true),

--- a/xtask/src/sourcegen/kinds.rs
+++ b/xtask/src/sourcegen/kinds.rs
@@ -41,33 +41,33 @@
 impl TokenKind {
 	pub fn grammar_name(&self) -> &str {
 		match self {
-			TokenKind::Keyword { code, .. } => code,
-			TokenKind::Literal { grammar_name, .. } => grammar_name,
-			TokenKind::Meta { grammar_name, .. } => grammar_name,
-			TokenKind::Error { grammar_name, .. } => grammar_name,
+			Self::Keyword { code, .. } => code,
+			Self::Literal { grammar_name, .. }
+			| Self::Meta { grammar_name, .. }
+			| Self::Error { grammar_name, .. } => grammar_name,
 		}
 	}
 	/// How this keyword should appear in kinds enum, screaming snake cased
 	pub fn name(&self) -> &str {
 		match self {
-			TokenKind::Keyword { name, .. } => name,
-			TokenKind::Literal { name, .. } => name,
-			TokenKind::Meta { name, .. } => name,
-			TokenKind::Error { name, .. } => name,
+			Self::Keyword { name, .. }
+			| Self::Literal { name, .. }
+			| Self::Meta { name, .. }
+			| Self::Error { name, .. } => name,
 		}
 	}
 	pub fn expand_kind(&self) -> TokenStream {
 		let name = format_ident!("{}", self.name());
 		let attr = match self {
-			TokenKind::Keyword { code, .. } => quote! {#[token(#code)]},
-			TokenKind::Literal { regex, lexer, .. } => {
+			Self::Keyword { code, .. } => quote! {#[token(#code)]},
+			Self::Literal { regex, lexer, .. } => {
 				let lexer = lexer
 					.as_deref()
 					.map(TokenStream::from_str)
 					.map(|r| r.expect("path is correct"));
 				quote! {#[regex(#regex, #lexer)]}
 			}
-			TokenKind::Error {
+			Self::Error {
 				regex, priority, ..
 			} if regex.is_some() => {
 				let priority = priority.map(|p| quote! {, priority = #p});
@@ -82,7 +82,7 @@
 	}
 	pub fn expand_t_macros(&self) -> Option<TokenStream> {
 		match self {
-			TokenKind::Keyword { code, name } => {
+			Self::Keyword { code, name } => {
 				let code = escape_token_macro(code);
 				let name = format_ident!("{name}");
 				Some(quote! {
@@ -98,29 +98,26 @@
 	/// Keywords are referenced with `T![_]` macro,
 	/// and literals are referenced directly by name
 	pub fn reference(&self) -> TokenStream {
-		match self {
-			TokenKind::Keyword { code, .. } => {
-				let code = escape_token_macro(code);
-				quote! {T![#code]}
-			}
-			_ => {
-				let name = self.name();
-				let ident = format_ident!("{name}");
-				quote! {#ident}
-			}
+		if let Self::Keyword { code, .. } = self {
+			let code = escape_token_macro(code);
+			quote! {T![#code]}
+		} else {
+			let name = self.name();
+			let ident = format_ident!("{name}");
+			quote! {#ident}
 		}
 	}
 
 	pub fn method_name(&self) -> Ident {
 		match self {
-			TokenKind::Keyword { name, .. } => {
+			Self::Keyword { name, .. } => {
 				format_ident!("{}_token", name.to_lowercase())
 			}
-			TokenKind::Literal { name, .. } => {
+			Self::Literal { name, .. } => {
 				format_ident!("{}_lit", name.to_lowercase())
 			}
-			TokenKind::Meta { name, .. } => format_ident!("{}_meta", name.to_lowercase()),
-			TokenKind::Error { name, .. } => format_ident!("{}_error", name.to_lowercase()),
+			Self::Meta { name, .. } => format_ident!("{}_meta", name.to_lowercase()),
+			Self::Error { name, .. } => format_ident!("{}_error", name.to_lowercase()),
 		}
 	}
 }
@@ -188,15 +185,14 @@
 				.is_none(),
 			"token already defined: {}",
 			token.grammar_name()
-		)
+		);
 	}
 	pub fn define_node(&mut self, node: &str) {
 		assert!(
 			self.defined_node_names.insert(node.to_owned()),
-			"node name already defined: {}",
-			node
+			"node name already defined: {node}"
 		);
-		self.nodes.push(node.to_string())
+		self.nodes.push(node.to_string());
 	}
 	pub fn token(&self, tok: &str) -> Option<&TokenKind> {
 		self.defined_tokens.get(tok)

--- a/xtask/src/sourcegen/mod.rs
+++ b/xtask/src/sourcegen/mod.rs
@@ -49,27 +49,27 @@
 				match special {
 					SpecialName::Literal => panic!("literal is not defined: {name}"),
 					SpecialName::Meta => {
-						eprintln!("implicit meta: {}", name);
+						eprintln!("implicit meta: {name}");
 						kinds.define_token(TokenKind::Meta {
 							grammar_name: token.to_owned(),
-							name: format!("META_{}", name),
-						})
+							name: format!("META_{name}"),
+						});
 					}
 					SpecialName::Error => {
-						eprintln!("implicit error: {}", name);
+						eprintln!("implicit error: {name}");
 						kinds.define_token(TokenKind::Error {
 							grammar_name: token.to_owned(),
-							name: format!("ERROR_{}", name),
+							name: format!("ERROR_{name}"),
 							regex: None,
 							priority: None,
 							is_lexer_error: true,
-						})
+						});
 					}
 				};
 				continue;
 			};
 			let name = to_upper_snake_case(token);
-			eprintln!("implicit kw: {}", token);
+			eprintln!("implicit kw: {token}");
 			kinds.define_token(TokenKind::Keyword {
 				code: token.to_owned(),
 				name: format!("{name}_KW"),
@@ -98,14 +98,14 @@
 			"/../crates/jrsonnet-rowan-parser/src/generated/syntax_kinds.rs",
 		)),
 		&syntax_kinds,
-	)?;
+	);
 	ensure_file_contents(
 		&PathBuf::from(concat!(
 			env!("CARGO_MANIFEST_DIR"),
 			"/../crates/jrsonnet-rowan-parser/src/generated/nodes.rs",
 		)),
 		&nodes,
-	)?;
+	);
 	Ok(())
 }
 
@@ -189,6 +189,7 @@
 	reformat(&ast.to_string())
 }
 
+#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
 fn generate_nodes(kinds: &KindsSrc, grammar: &AstSrc) -> Result<String> {
 	let (node_defs, node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar
 		.nodes
@@ -524,7 +525,7 @@
 fn write_doc_comment(contents: &[String], dest: &mut String) {
 	use std::fmt::Write;
 	for line in contents {
-		writeln!(dest, "///{}", line).unwrap();
+		writeln!(dest, "///{line}").unwrap();
 	}
 }
 

--- a/xtask/src/sourcegen/util.rs
+++ b/xtask/src/sourcegen/util.rs
@@ -1,3 +1,5 @@
+// FIXME: Replace various helper here with inflector?
+
 use std::{fs, path::Path};
 
 use anyhow::Result;
@@ -5,11 +7,11 @@
 
 /// Checks that the `file` has the specified `contents`. If that is not the
 /// case, updates the file and then fails the test.
-pub fn ensure_file_contents(file: &Path, contents: &str) -> Result<()> {
+pub fn ensure_file_contents(file: &Path, contents: &str) {
 	if let Ok(old_contents) = fs::read_to_string(file) {
 		if normalize_newlines(&old_contents) == normalize_newlines(contents) {
 			// File is already up to date.
-			return Ok(());
+			return;
 		}
 	}
 
@@ -18,7 +20,6 @@
 		let _ = fs::create_dir_all(parent);
 	}
 	fs::write(file, contents).unwrap();
-	Ok(())
 }
 
 // Eww, someone configured git to use crlf?
@@ -26,8 +27,9 @@
 	s.replace("\r\n", "\n")
 }
 
-pub(crate) fn pluralize(s: &str) -> String {
-	format!("{}s", s)
+pub fn pluralize(s: &str) -> String {
+	// FIXME: Inflector?
+	format!("{s}s")
 }
 
 pub fn to_upper_snake_case(s: &str) -> String {
@@ -35,7 +37,7 @@
 	let mut prev = false;
 	for c in s.chars() {
 		if c.is_ascii_uppercase() && prev {
-			buf.push('_')
+			buf.push('_');
 		}
 		prev = true;
 
@@ -48,7 +50,7 @@
 	let mut prev = false;
 	for c in s.chars() {
 		if c.is_ascii_uppercase() && prev {
-			buf.push('_')
+			buf.push('_');
 		}
 		prev = true;