difftreelog
style fix clippy warnings
in: master
19 files changed
bindings/jsonnet/src/import.rsdiffbeforeafterboth--- 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
bindings/jsonnet/src/lib.rsdiffbeforeafterboth--- 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
bindings/jsonnet/src/val_extract.rsdiffbeforeafterboth--- 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,
bindings/jsonnet/src/val_make.rsdiffbeforeafterboth--- 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`.
bindings/jsonnet/src/val_modify.rsdiffbeforeafterboth12///12///13/// # Safety13/// # Safety14///14///15/// `arr` should be a pointer to array value allocated by make_array, or returned by other library call15/// `arr` should be a pointer to array value allocated by `make_array`, or returned by other library call16/// `val` should be a pointer to value allocated using this library16/// `val` should be a pointer to value allocated using this library17#[no_mangle]17#[no_mangle]18pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &VM, arr: &mut Val, val: &Val) {18pub unsafe extern "C" fn jsonnet_json_array_append(_vm: &VM, arr: &mut Val, val: &Val) {bindings/jsonnet/src/vars_tlas.rsdiffbeforeafterboth--- 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.
cmds/jrsonnet-fmt/src/children.rsdiffbeforeafterboth--- 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()
- )
+ );
}
}
cmds/jrsonnet-fmt/src/comments.rsdiffbeforeafterboth--- 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
cmds/jrsonnet-fmt/src/main.rsdiffbeforeafterboth--- 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(())
}
crates/jrsonnet-rowan-parser/src/lex.rsdiffbeforeafterboth--- 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,
- })
+ });
}
}
}
crates/jrsonnet-rowan-parser/src/marker.rsdiffbeforeafterboth--- 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,
crates/jrsonnet-rowan-parser/src/parser.rsdiffbeforeafterboth--- 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);
}
crates/jrsonnet-rowan-parser/src/precedence.rsdiffbeforeafterboth--- 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),
}
}
}
crates/jrsonnet-rowan-parser/src/string_block.rsdiffbeforeafterboth--- 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("|||") {
crates/jrsonnet-rowan-parser/src/token_set.rsdiffbeforeafterboth--- 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)
}
xtask/src/sourcegen/ast.rsdiffbeforeafterboth--- 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),
xtask/src/sourcegen/kinds.rsdiffbeforeafterboth--- 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)
xtask/src/sourcegen/mod.rsdiffbeforeafterboth--- 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();
}
}
xtask/src/sourcegen/util.rsdiffbeforeafterboth--- 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;