chore: apply fixes to all the codebase with cargo clippy --fix

ci-gen/src/ghwf.rs

@@ -3,19 +3,14 @@ use std::fmt;
 use crate::yaml::Yaml;
 
 #[allow(dead_code)]
-#[derive(Copy, Clone, Eq, PartialEq)]
+#[derive(Copy, Clone, Eq, PartialEq, Default)]
 pub enum Env {
     WindowsLatest,
+    #[default]
     UbuntuLatest,
     MacosLatest,
 }
 
-impl Default for Env {
-    fn default() -> Self {
-        Env::UbuntuLatest
-    }
-}
-
 impl fmt::Display for Env {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
@@ -60,7 +55,7 @@ impl Step {
             name: name.to_owned(),
             uses: Some(uses.to_owned()),
             env: env
-                .into_iter()
+                .iter()
                 .map(|(k, v)| (String::from(*k), String::from(*v)))
                 .collect(),
             with: Some(with),
@@ -85,16 +80,16 @@ impl Step {
     }
 }
 
-impl Into<Yaml> for Step {
-    fn into(self) -> Yaml {
+impl From<Step> for Yaml {
+    fn from(val: Step) -> Self {
         let Step {
             name,
             uses,
             with,
             run,
             shell,
             env,
-        } = self;
+        } = val;
         let mut entries = Vec::new();
         entries.push(("name", Yaml::string(name)));
         if let Some(uses) = uses {
@@ -134,23 +129,23 @@ impl Job {
     }
 }
 
-impl Into<(String, Yaml)> for Job {
-    fn into(self) -> (String, Yaml) {
-        assert!(!self.id.is_empty());
+impl From<Job> for (String, Yaml) {
+    fn from(val: Job) -> Self {
+        assert!(!val.id.is_empty());
         let mut entries = vec![
-            ("name", Yaml::string(self.name)),
-            ("runs-on", Yaml::string(format!("{}", self.runs_on))),
+            ("name", Yaml::string(val.name)),
+            ("runs-on", Yaml::string(format!("{}", val.runs_on))),
         ];
-        if let Some(timeout_minutes) = self.timeout_minutes {
+        if let Some(timeout_minutes) = val.timeout_minutes {
             entries.push((
                 "timeout-minutes",
                 Yaml::string(format!("{}", timeout_minutes)),
             ));
         }
-        if !self.env.is_empty() {
-            entries.push(("env", Yaml::map(self.env)));
+        if !val.env.is_empty() {
+            entries.push(("env", Yaml::map(val.env)));
         }
-        entries.push(("steps", Yaml::list(self.steps)));
-        (self.id, Yaml::map(entries))
+        entries.push(("steps", Yaml::list(val.steps)));
+        (val.id, Yaml::map(entries))
     }
 }

ci-gen/src/main.rs

@@ -55,9 +55,9 @@ enum Features {
 impl Features {
     fn flag(&self) -> String {
         match self {
-            Features::Default => format!(""),
+            Features::Default => String::new(),
             Features::Specific(f) => format!("--features={}", f.join(",")),
-            Features::All => format!("--all-features"),
+            Features::All => "--all-features".to_string(),
         }
     }
 
@@ -72,25 +72,25 @@ impl Features {
 
     fn id(&self) -> String {
         match self {
-            Features::Default => format!("default-features"),
-            Features::All => format!("all-features"),
+            Features::Default => "default-features".to_string(),
+            Features::All => "all-features".to_string(),
             Features::Specific(s) => s.join("-"),
         }
     }
 
     fn name(&self) -> String {
         match self {
-            Features::Default => format!("default features"),
-            Features::All => format!("all features"),
+            Features::Default => "default features".to_string(),
+            Features::All => "all features".to_string(),
             Features::Specific(s) => s.join(","),
         }
     }
 }
 
 fn self_check_job() -> Job {
     Job {
-        id: format!("self-check"),
-        name: format!("CI self-check"),
+        id: "self-check".to_string(),
+        name: "CI self-check".to_string(),
         runs_on: LINUX.ghwf,
         steps: vec![
             checkout_sources(),

ci-gen/src/yaml.rs

@@ -61,23 +61,18 @@ pub struct YamlWriter {
     minus: MinusState,
 }
 
-#[derive(Eq, PartialEq)]
+#[derive(Eq, PartialEq, Default)]
 enum MinusState {
+    #[default]
     No,
     Yes,
     Already,
 }
 
-impl Default for MinusState {
-    fn default() -> Self {
-        MinusState::No
-    }
-}
-
 impl YamlWriter {
     pub fn write_line(&mut self, line: &str) {
         if line.is_empty() {
-            self.buffer.push_str("\n");
+            self.buffer.push('\n');
         } else {
             for _ in 0..self.indent {
                 self.buffer.push_str("    ");
@@ -95,7 +90,7 @@ impl YamlWriter {
             }
 
             self.buffer.push_str(line);
-            self.buffer.push_str("\n");
+            self.buffer.push('\n');
         }
     }
 

protobuf-codegen/src/codegen/mod.rs

@@ -14,18 +14,13 @@ use crate::customize::CustomizeCallbackHolder;
 use crate::gen_and_write::gen_and_write;
 use crate::Customize;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 enum WhichParser {
+    #[default]
     Pure,
     Protoc,
 }
 
-impl Default for WhichParser {
-    fn default() -> WhichParser {
-        WhichParser::Pure
-    }
-}
-
 #[derive(Debug, thiserror::Error)]
 enum CodegenError {
     #[error("out_dir is not specified")]
@@ -221,9 +216,9 @@ impl Codegen {
 
         if self.create_out_dir {
             if out_dir.exists() {
-                fs::remove_dir_all(&out_dir)?;
+                fs::remove_dir_all(out_dir)?;
             }
-            fs::create_dir(&out_dir)?;
+            fs::create_dir(out_dir)?;
         }
 
         let mut parser = Parser::new();
@@ -257,7 +252,7 @@ impl Codegen {
             &parsed_and_typechecked.file_descriptors,
             &parsed_and_typechecked.parser,
             &parsed_and_typechecked.relative_paths,
-            &out_dir,
+            out_dir,
             &self.customize,
             &*self.customize_callback,
         )

protobuf-codegen/src/gen/all.rs

@@ -42,11 +42,13 @@ pub(crate) fn gen_all(
     };
 
     for file_name in files_to_generate {
-        let file = files_map.get(file_name.as_path()).expect(&format!(
-            "file not found in file descriptors: {:?}, files: {:?}",
-            file_name,
-            files_map.keys()
-        ));
+        let file = files_map.get(file_name.as_path()).unwrap_or_else(|| {
+            panic!(
+                "file not found in file descriptors: {:?}, files: {:?}",
+                file_name,
+                files_map.keys()
+            )
+        });
         let gen_file_result = gen_file(file, &files_map, &root_scope, &customize, parser)?;
         results.push(gen_file_result.compiler_plugin_result);
         mods.push(gen_file_result.mod_name);

protobuf-codegen/src/gen/code_writer.rs

@@ -23,7 +23,11 @@ impl<'a> CodeWriter<'a> {
     }
 
     pub(crate) fn with_no_error(f: impl FnOnce(&mut CodeWriter)) -> String {
-        Self::with_impl::<Infallible, _>(|w| Ok(f(w))).unwrap_or_else(|e| match e {})
+        Self::with_impl::<Infallible, _>(|w| {
+            f(w);
+            Ok(())
+        })
+        .unwrap_or_else(|e| match e {})
     }
 
     pub(crate) fn with<F>(f: F) -> anyhow::Result<String>
@@ -47,7 +51,7 @@ impl<'a> CodeWriter<'a> {
 
     pub(crate) fn write_line<S: AsRef<str>>(&mut self, line: S) {
         if line.as_ref().is_empty() {
-            self.writer.push_str("\n");
+            self.writer.push('\n');
         } else {
             let s: String = [self.indent.as_ref(), line.as_ref(), "\n"].concat();
             self.writer.push_str(&s);
@@ -96,7 +100,7 @@ impl<'a> CodeWriter<'a> {
     }
 
     pub(crate) fn unimplemented(&mut self) {
-        self.write_line(format!("unimplemented!();"));
+        self.write_line("unimplemented!();");
     }
 
     pub(crate) fn indented<F>(&mut self, cb: F)
@@ -331,11 +335,7 @@ impl<'a> CodeWriter<'a> {
             .and_then(|ls| ls.iter().find(|l| l.path == path))
             .map(|l| l.leading_comments());
 
-        let lines = doc
-            .iter()
-            .map(|doc| doc.lines())
-            .flatten()
-            .collect::<Vec<_>>();
+        let lines = doc.iter().flat_map(|doc| doc.lines()).collect::<Vec<_>>();
 
         // Skip comments with code blocks to avoid rustdoc trying to compile them.
         if !lines.iter().any(|line| line.starts_with("    ")) {

protobuf-codegen/src/gen/enums.rs

@@ -167,7 +167,7 @@ impl<'a> EnumGen<'a> {
             w.comment("Note: you cannot use pattern matching for enums with allow_alias option");
         }
         w.derive(&derive);
-        let ref type_name = self.type_name;
+        let type_name = &self.type_name;
         write_protoc_insertion_point_for_enum(
             w,
             &self.customize.for_elem,
@@ -294,7 +294,7 @@ impl<'a> EnumGen<'a> {
     }
 
     fn write_impl_enum_full(&self, w: &mut CodeWriter) {
-        let ref type_name = self.type_name;
+        let type_name = &self.type_name;
         w.impl_for_block(
             &format!(
                 "{}::EnumFull",
@@ -351,7 +351,7 @@ impl<'a> EnumGen<'a> {
                 });
                 w.write_line("};");
             }
-            w.write_line(&format!("Self::enum_descriptor().value_by_index(index)"));
+            w.write_line("Self::enum_descriptor().value_by_index(index)");
         });
     }
 

protobuf-codegen/src/gen/field/accessor.rs

@@ -27,9 +27,9 @@ impl AccessorFn {
         s.push_str("::<_");
         for p in &self.type_params {
             s.push_str(", ");
-            s.push_str(&p);
+            s.push_str(p);
         }
-        s.push_str(">");
+        s.push('>');
         s
     }
 }