From afe1286f67ce29c4c62dcac8d24f467f431f5a56 Mon Sep 17 00:00:00 2001 From: Yaroslav Bolyukin Date: Sun, 19 May 2024 20:21:09 +0000 Subject: [PATCH] style: fix clippy warnings --- --- 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::() { - 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::() } /// # 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::>(); - 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::

().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, { + 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, { + 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, { - 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::( 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 { + Self::ObjBodyMemberList(l) => { let (children, end_comments) = children_between::( 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::( 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, { - 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, { - 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, - ) -> 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) -> CompletedMarker { + pub fn wrap_error(self, p: &mut Parser, msg: impl AsRef) -> Self { self.wrap_raw( p, 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>, } @@ -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) -> Result<(), StringBlockError> { struct Context<'a> { source: &'a str, @@ -78,6 +79,7 @@ }; } + #[allow(clippy::range_plus_one)] fn pos(&self) -> Range { 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 = >::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 = >::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 { 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 { 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::>(); @@ -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 { 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 { 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; -- gitstuff