Fix clippy warnings.

Author: trypsynth

build.rs

@@ -228,31 +228,31 @@ fn validate_languages(languages: &[Language]) -> Result<()> {
 		if let Some(ref block_comments) = lang.block_comments {
 			for (comment_idx, comment_pair) in block_comments.iter().enumerate() {
 				if comment_pair.len() == 2 {
-    					let (start, end) = (&comment_pair[0], &comment_pair[1]);
-    					if start.is_empty() {
-    						errors.push(format!(
-    							"{} ('{}'), block comment {}: Block comment start cannot be empty",
-    							position,
-    							lang.name,
-    							comment_idx + 1
-    						));
-    					}
-    					if end.is_empty() {
-    						errors.push(format!(
-    							"{} ('{}'), block comment {}: Block comment end cannot be empty",
-    							position,
-    							lang.name,
-    							comment_idx + 1
-    						));
-    					}
-    				} else {
-    					errors.push(format!(
-    						"{} ('{}'), block comment {}: Block comment must have exactly 2 elements (start, end)",
-    						position,
-    						lang.name,
-    						comment_idx + 1
-    					));
-    				}
+					let (start, end) = (&comment_pair[0], &comment_pair[1]);
+					if start.is_empty() {
+						errors.push(format!(
+							"{} ('{}'), block comment {}: Block comment start cannot be empty",
+							position,
+							lang.name,
+							comment_idx + 1
+						));
+					}
+					if end.is_empty() {
+						errors.push(format!(
+							"{} ('{}'), block comment {}: Block comment end cannot be empty",
+							position,
+							lang.name,
+							comment_idx + 1
+						));
+					}
+				} else {
+					errors.push(format!(
+						"{} ('{}'), block comment {}: Block comment must have exactly 2 elements (start, end)",
+						position,
+						lang.name,
+						comment_idx + 1
+					));
+				}
 			}
 		}
 	}

src/analysis/analyzer.rs

@@ -34,31 +34,37 @@ impl AnalysisOptions {
 		}
 	}
 
-	pub fn verbose(mut self, verbose: bool) -> Self {
+	#[must_use]
+	pub const fn verbose(mut self, verbose: bool) -> Self {
 		self.verbose = verbose;
 		self
 	}
 
-	pub fn respect_gitignore(mut self, respect: bool) -> Self {
+	#[must_use]
+	pub const fn respect_gitignore(mut self, respect: bool) -> Self {
 		self.respect_gitignore = respect;
 		self
 	}
 
-	pub fn include_hidden(mut self, include: bool) -> Self {
+	#[must_use]
+	pub const fn include_hidden(mut self, include: bool) -> Self {
 		self.include_hidden = include;
 		self
 	}
 
-	pub fn follow_symlinks(mut self, follow: bool) -> Self {
+	#[must_use]
+	pub const fn follow_symlinks(mut self, follow: bool) -> Self {
 		self.follow_symlinks = follow;
 		self
 	}
 
+	#[must_use]
 	pub fn path(&self) -> &Path {
 		&self.path
 	}
 
-	pub fn is_verbose(&self) -> bool {
+	#[must_use]
+	pub const fn is_verbose(&self) -> bool {
 		self.verbose
 	}
 }
@@ -68,7 +74,8 @@ pub struct CodeAnalyzer {
 }
 
 impl CodeAnalyzer {
-	pub fn new(options: AnalysisOptions) -> Self {
+	#[must_use]
+	pub const fn new(options: AnalysisOptions) -> Self {
 		Self { options }
 	}
 

src/analysis/line_classifier.rs

@@ -17,18 +17,19 @@ pub struct CommentState {
 }
 
 impl CommentState {
+	#[must_use]
 	pub fn new() -> Self {
 		Self::default()
 	}
 
-	pub fn enter_block(&mut self, nested: bool) {
+	pub const fn enter_block(&mut self, nested: bool) {
 		self.in_block_comment = true;
 		if nested {
 			self.block_comment_depth = 1;
 		}
 	}
 
-	pub fn exit_block(&mut self, nested: bool) {
+	pub const fn exit_block(&mut self, nested: bool) {
 		if nested {
 			self.block_comment_depth = self.block_comment_depth.saturating_sub(1);
 			if self.block_comment_depth == 0 {
@@ -40,11 +41,12 @@ impl CommentState {
 		}
 	}
 
-	pub fn enter_nested_block(&mut self) {
+	pub const fn enter_nested_block(&mut self) {
 		self.block_comment_depth += 1;
 	}
 
-	pub fn is_in_comment(&self) -> bool {
+	#[must_use]
+	pub const fn is_in_comment(&self) -> bool {
 		self.in_block_comment
 	}
 }

src/analysis/stats.rs

@@ -15,7 +15,8 @@ pub struct FileStats {
 }
 
 impl FileStats {
-	pub fn new(
+	#[must_use]
+	pub const fn new(
 		path: String,
 		total_lines: u64,
 		code_lines: u64,
@@ -27,31 +28,38 @@ impl FileStats {
 		Self { path, total_lines, code_lines, comment_lines, blank_lines, shebang_lines, size }
 	}
 
+	#[must_use]
 	pub fn path(&self) -> &str {
 		&self.path
 	}
 
-	pub fn total_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_lines(&self) -> u64 {
 		self.total_lines
 	}
 
-	pub fn code_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn code_lines(&self) -> u64 {
 		self.code_lines
 	}
 
-	pub fn comment_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn comment_lines(&self) -> u64 {
 		self.comment_lines
 	}
 
-	pub fn blank_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn blank_lines(&self) -> u64 {
 		self.blank_lines
 	}
 
-	pub fn shebang_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn shebang_lines(&self) -> u64 {
 		self.shebang_lines
 	}
 
-	pub fn size(&self) -> u64 {
+	#[must_use]
+	pub const fn size(&self) -> u64 {
 		self.size
 	}
 }
@@ -81,50 +89,62 @@ impl LanguageStats {
 		self.file_list.push(file_stats);
 	}
 
-	pub fn files(&self) -> u64 {
+	#[must_use]
+	pub const fn files(&self) -> u64 {
 		self.files
 	}
 
-	pub fn lines(&self) -> u64 {
+	#[must_use]
+	pub const fn lines(&self) -> u64 {
 		self.lines
 	}
 
-	pub fn code_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn code_lines(&self) -> u64 {
 		self.code_lines
 	}
 
-	pub fn comment_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn comment_lines(&self) -> u64 {
 		self.comment_lines
 	}
 
-	pub fn blank_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn blank_lines(&self) -> u64 {
 		self.blank_lines
 	}
 
-	pub fn shebang_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn shebang_lines(&self) -> u64 {
 		self.shebang_lines
 	}
 
-	pub fn size(&self) -> u64 {
+	#[must_use]
+	pub const fn size(&self) -> u64 {
 		self.size
 	}
 
+	#[must_use]
 	pub fn files_list(&self) -> &[FileStats] {
 		&self.file_list
 	}
 
+	#[must_use]
 	pub fn code_percentage(&self) -> f64 {
 		utils::percentage(self.code_lines, self.lines)
 	}
 
+	#[must_use]
 	pub fn comment_percentage(&self) -> f64 {
 		utils::percentage(self.comment_lines, self.lines)
 	}
 
+	#[must_use]
 	pub fn blank_percentage(&self) -> f64 {
 		utils::percentage(self.blank_lines, self.lines)
 	}
 
+	#[must_use]
 	pub fn shebang_percentage(&self) -> f64 {
 		utils::percentage(self.shebang_lines, self.lines)
 	}
@@ -155,56 +175,69 @@ impl AnalysisResults {
 		self.language_stats.entry(language).or_default().add_file(file_stats);
 	}
 
-	pub fn total_files(&self) -> u64 {
+	#[must_use]
+	pub const fn total_files(&self) -> u64 {
 		self.total_files
 	}
 
-	pub fn total_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_lines(&self) -> u64 {
 		self.total_lines
 	}
 
-	pub fn total_code_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_code_lines(&self) -> u64 {
 		self.total_code_lines
 	}
 
-	pub fn total_comment_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_comment_lines(&self) -> u64 {
 		self.total_comment_lines
 	}
 
-	pub fn total_blank_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_blank_lines(&self) -> u64 {
 		self.total_blank_lines
 	}
 
-	pub fn total_shebang_lines(&self) -> u64 {
+	#[must_use]
+	pub const fn total_shebang_lines(&self) -> u64 {
 		self.total_shebang_lines
 	}
 
-	pub fn total_size(&self) -> u64 {
+	#[must_use]
+	pub const fn total_size(&self) -> u64 {
 		self.total_size
 	}
 
-	pub fn language_stats(&self) -> &HashMap<String, LanguageStats> {
+	#[must_use]
+	pub const fn language_stats(&self) -> &HashMap<String, LanguageStats> {
 		&self.language_stats
 	}
 
+	#[must_use]
 	pub fn languages_by_lines(&self) -> Vec<(&String, &LanguageStats)> {
 		let mut stats_vec: Vec<_> = self.language_stats.iter().collect();
 		stats_vec.sort_by_key(|(_, lang_stats)| std::cmp::Reverse(lang_stats.lines));
 		stats_vec
 	}
 
+	#[must_use]
 	pub fn code_percentage(&self) -> f64 {
 		utils::percentage(self.total_code_lines, self.total_lines)
 	}
 
+	#[must_use]
 	pub fn comment_percentage(&self) -> f64 {
 		utils::percentage(self.total_comment_lines, self.total_lines)
 	}
 
+	#[must_use]
 	pub fn blank_percentage(&self) -> f64 {
 		utils::percentage(self.total_blank_lines, self.total_lines)
 	}
 
+	#[must_use]
 	pub fn shebang_percentage(&self) -> f64 {
 		utils::percentage(self.total_shebang_lines, self.total_lines)
 	}

src/lib.rs

@@ -1,3 +1,5 @@
+#![warn(clippy::all, clippy::pedantic, clippy::nursery)]
+
 pub mod analysis;
 pub mod cli;
 pub mod display;

src/main.rs

@@ -1,3 +1,5 @@
+#![warn(clippy::all, clippy::pedantic, clippy::nursery)]
+
 use anyhow::{Result, ensure};
 use clap::Parser;
 use codestats::{

src/utils.rs

@@ -1,7 +1,7 @@
-pub(crate) fn pluralize<'a>(count: u64, singular: &'a str, plural: &'a str) -> &'a str {
+pub const fn pluralize<'a>(count: u64, singular: &'a str, plural: &'a str) -> &'a str {
 	if count == 1 { singular } else { plural }
 }
 
-pub(crate) fn percentage(part: u64, total: u64) -> f64 {
+pub fn percentage(part: u64, total: u64) -> f64 {
 	if total == 0 { 0.0 } else { (part as f64 / total as f64) * 100.0 }
 }