chore: run cargo fmt and apply clippy lints

Author: walker84837

kitc/src/main.rs

@@ -69,7 +69,7 @@ fn main() -> Result<(), Error> {
 
 fn compile(source: &PathBuf, libs: &[String], measure: bool) -> Result<PathBuf, String> {
     let init = time::Instant::now();
-    fs::read_to_string(source).map_err(|_| format!("couldn't read {:?}", source))?;
+    fs::read_to_string(source).map_err(|_| format!("couldn't read {}", source.display()))?;
 
     let ext = if cfg!(windows) { "exe" } else { "" };
     let exe_path = source.with_extension(ext);
@@ -92,7 +92,7 @@ fn compile(source: &PathBuf, libs: &[String], measure: bool) -> Result<PathBuf,
 fn run_executable(exe_path: &PathBuf) -> Result<(), String> {
     let status = Command::new(exe_path)
         .status()
-        .map_err(|e| format!("failed to launch executable: {}", e))?;
+        .map_err(|e| format!("failed to launch executable: {e}"))?;
 
     if !status.success() {
         std::process::exit(status.code().unwrap_or(1));

kitc/tests/examples.rs

@@ -23,8 +23,8 @@ fn run_example_test(
         .ok_or("couldn't get workspace root")?;
 
     let examples_dir = workspace_root.join("examples");
-    let example_file = examples_dir.join(format!("{}.kit", example_name));
-    let expected_file = examples_dir.join(format!("{}.kit.expected", example_name));
+    let example_file = examples_dir.join(format!("{example_name}.kit"));
+    let expected_file = examples_dir.join(format!("{example_name}.kit.expected"));
 
     assert!(
         example_file.exists(),
@@ -39,8 +39,7 @@ fn run_example_test(
     );
 
     log::info!(
-        "Running example {} in {} (path: {}). Expected file is at {}",
-        example_name,
+        "Running example {example_name} in {} (path: {}). Expected file is at {}",
         workspace_root.display(),
         example_file.display(),
         expected_file.display()

kitlang/src/codegen/ast.rs

@@ -1,4 +1,4 @@
-use crate::codegen::types::*;
+use crate::codegen::types::{AssignmentOperator, BinaryOperator, Type, TypeId, UnaryOperator};
 
 use std::collections::HashSet;
 
@@ -169,15 +169,16 @@ pub enum Literal {
 
 impl Literal {
     /// Converts the literal to its C representation string.
+    #[must_use]
     pub fn to_c(&self) -> String {
         match self {
             Literal::Int(i) => i.to_string(),
             Literal::Float(f) => {
                 // Ensure float literals have 'f' suffix in C
                 if f.fract() == 0.0 {
-                    format!("{}.0f", f)
+                    format!("{f}.0f")
                 } else {
-                    format!("{}f", f)
+                    format!("{f}f")
                 }
             }
             Literal::String(s) => {
@@ -192,7 +193,7 @@ impl Literal {
                         _ => c.to_string(),
                     })
                     .collect();
-                format!("\"{}\"", escaped)
+                format!("\"{escaped}\"")
             }
             Literal::Bool(b) => b.to_string(),
             Literal::Null => "NULL".to_string(),

kitlang/src/codegen/compiler.rs

@@ -146,7 +146,7 @@ impl Toolchain {
         match self {
             Toolchain::Gcc | Toolchain::Clang => {
                 let flags = ["-std=c99", "-Wall", "-Wextra", "-pedantic"];
-                flags.iter().map(|s| s.to_string()).collect()
+                flags.iter().map(ToString::to_string).collect()
             }
             #[cfg(windows)]
             Toolchain::Msvc => {
@@ -181,7 +181,7 @@ pub struct CompilerOptions {
     pub link_opts: Vec<String>,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub struct CompilerMeta(pub Toolchain);
 
 impl CompilerOptions {
@@ -256,9 +256,10 @@ impl CompilerOptions {
 
     /// Build the compiler invocation used to spawn `Command`.
     ///
-    /// Returns (path_to_compiler_executable, args_vec).
+    /// Returns (`path_to_compiler_executable`, `args_vec`).
+    ///
+    /// # Errors
     ///
-    /// Errors:
     /// - if `sources` is empty
     /// - if `output` is not set
     /// - if no system compiler can be found and no `enforced_toolchain` is usable

kitlang/src/codegen/frontend.rs

@@ -1,12 +1,13 @@
-use crate::{KitParser, Rule, error::CompilationError};
 use crate::error::CompileResult;
+use crate::{KitParser, Rule, error::CompilationError};
 use pest::Parser;
 
 use std::collections::HashSet;
+use std::fmt::Write;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
-use crate::codegen::ast::*;
+use crate::codegen::ast::{Block, Expr, Function, Include, Program, Stmt};
 use crate::codegen::compiler::{CompilerMeta, CompilerOptions, Toolchain};
 use crate::codegen::inference::TypeInferencer;
 use crate::codegen::parser::Parser as CodeParser;
@@ -60,7 +61,7 @@ impl Compiler {
             }
         }
 
-        self.includes = includes.clone();
+        self.includes.clone_from(&includes);
 
         Ok(Program {
             includes,
@@ -70,10 +71,10 @@ impl Compiler {
     }
 
     /// Generate C code from the AST and write it to the output path
-    fn transpile_with_program(&mut self, prog: Program) {
-        let c_code = self.generate_c_code(&prog);
+    fn transpile_with_program(&mut self, prog: &Program) {
+        let c_code = self.generate_c_code(prog);
         if let Err(e) = std::fs::write(&self.c_output, c_code) {
-            panic!("Failed to write output: {}", e);
+            panic!("Failed to write output: {e}");
         }
     }
 
@@ -134,7 +135,7 @@ impl Compiler {
 
         // emit unique headers
         for hdr in seen_headers {
-            out.push_str(&format!("#include {}\n", hdr));
+            writeln!(out, "#include {hdr}").unwrap();
         }
         out.push('\n');
 
@@ -213,16 +214,15 @@ impl Compiler {
                         .inferencer
                         .store
                         .resolve(*inferred)
-                        .map(|t| t.to_c_repr().name)
-                        .unwrap_or_else(|_| "auto".to_string());
+                        .map_or_else(|_| "auto".to_string(), |t| t.to_c_repr().name);
 
                     match init {
                         Some(expr) => {
                             let init_str = self.transpile_expr(expr);
-                            format!("{} {} = {};\n", ty_str, name, init_str)
+                            format!("{ty_str} {name} = {init_str};\n")
                         }
                         None => {
-                            format!("{} {};\n", ty_str, name)
+                            format!("{ty_str} {name};\n")
                         }
                     }
                 }
@@ -260,16 +260,12 @@ impl Compiler {
                     let mut s = if let Expr::RangeLiteral { start, end } = iter {
                         let start_str = self.transpile_expr(start);
                         let end_str = self.transpile_expr(end);
-                        format!(
-                            "for (int {} = {}; {} < {}; ++{}) ",
-                            var, start_str, var, end_str, var
-                        )
+                        format!("for (int {var} = {start_str}; {var} < {end_str}; ++{var}) ")
                     } else {
                         let iter_str = self.transpile_expr(iter);
-                        format!("for (int {} = 0; {} < {}; ++{}) ", var, var, iter_str, var)
+                        format!("for (int {var} = 0; {var} < {iter_str}; ++{var}) ")
                     };
                     s.push_str(&self.transpile_block(body));
-                    s.push('\n');
                     s
                 }
                 Stmt::Break => "break;\n".to_string(),
@@ -300,7 +296,7 @@ impl Compiler {
                     .map(|a| self.transpile_expr(a))
                     .collect::<Vec<_>>()
                     .join(", ");
-                format!("{}({})", callee, args_str)
+                format!("{callee}({args_str})")
             }
             Expr::UnaryOp { op, expr, ty: _ } => {
                 let expr_str = self.transpile_expr(expr);
@@ -314,7 +310,7 @@ impl Compiler {
             } => {
                 let left_str = self.transpile_expr(left);
                 let right_str = self.transpile_expr(right);
-                format!("({} {} {})", left_str, op.to_c_str(), right_str)
+                format!("({left_str} {} {right_str})", op.to_c_str())
             }
             Expr::Assign {
                 op,
@@ -324,7 +320,7 @@ impl Compiler {
             } => {
                 let left_str = self.transpile_expr(left);
                 let right_str = self.transpile_expr(right);
-                format!("{} {} {}", left_str, op.to_c_str(), right_str)
+                format!("{left_str} {} {right_str}", op.to_c_str())
             }
             Expr::If {
                 cond,
@@ -335,7 +331,7 @@ impl Compiler {
                 let cond_str = self.transpile_expr(cond);
                 let then_str = self.transpile_expr(then_branch);
                 let else_str = self.transpile_expr(else_branch);
-                format!("({} ? {} : {})", cond_str, then_str, else_str)
+                format!("({cond_str} ? {then_str} : {else_str})")
             }
             Expr::RangeLiteral { .. } => {
                 // Should technically not be used alone, but return something safe to avoid panic
@@ -348,7 +344,7 @@ impl Compiler {
         let mut prog = self.parse()?;
 
         self.inferencer.infer_program(&mut prog)?;
-        self.transpile_with_program(prog);
+        self.transpile_with_program(&prog);
 
         let detected = Toolchain::executable_path().ok_or(CompilationError::ToolchainNotFound)?;
 

kitlang/src/codegen/inference.rs

@@ -1,4 +1,4 @@
-use super::ast::*;
+use super::ast::{Block, Expr, Function, Literal, Program, Stmt};
 use super::symbols::SymbolTable;
 use super::types::{BinaryOperator, Type, TypeId, TypeStore, UnaryOperator};
 use crate::error::{CompilationError, CompileResult};
@@ -169,8 +169,7 @@ impl TypeInferencer {
                     .map_err(CompilationError::TypeError)?;
                 if iter_resolved != Type::Int && iter_resolved != Type::Void {
                     return Err(CompilationError::TypeError(format!(
-                        "For loop iterator must be Int or Range, found {:?}",
-                        iter_resolved
+                        "For loop iterator must be Int or Range, found {iter_resolved:?}"
                     )));
                 }
 
@@ -187,12 +186,12 @@ impl TypeInferencer {
         Ok(())
     }
 
-    /// Infer types for an expression.
+    /// Infer types for an expression
     fn infer_expr(&mut self, expr: &mut Expr) -> Result<TypeId, CompilationError> {
         let ty = match expr {
             Expr::Identifier(name, ty_id) => {
                 let var_ty = self.symbols.lookup_var(name).ok_or_else(|| {
-                    CompilationError::TypeError(format!("Use of undeclared variable '{}'", name))
+                    CompilationError::TypeError(format!("Use of undeclared variable '{name}'"))
                 })?;
                 *ty_id = var_ty;
                 var_ty
@@ -268,8 +267,7 @@ impl TypeInferencer {
                             self.store.new_known(*inner_ty)
                         } else {
                             return Err(CompilationError::TypeError(format!(
-                                "Cannot dereference non-pointer type: {:?}",
-                                resolved
+                                "Cannot dereference non-pointer type: {resolved:?}"
                             )));
                         }
                     }

kitlang/src/codegen/parser.rs

@@ -285,7 +285,7 @@ impl Parser {
                     Rule::unary_op => {
                         let op_str = first_pair.as_str();
                         let op = UnaryOperator::from_str(op_str)
-                            .map_err(|_| parse_error!("invalid unary operation: {}", op_str))?;
+                            .map_err(|()| parse_error!("invalid unary operation: {op_str}"))?;
 
                         // SAFETY: Grammar guarantees expression after unary op
                         let expr = self.parse_expr(inner_pairs.next().unwrap())?;
@@ -306,7 +306,7 @@ impl Parser {
                         })
                     }
                     Rule::primary => self.parse_expr(first_pair),
-                    _other => Err(parse_error!("Unexpected rule in unary: {:?}", _other)),
+                    other => Err(parse_error!("Unexpected rule in unary: {other:?}")),
                 }
             }
             Rule::identifier => Ok(Expr::Identifier(
@@ -396,21 +396,21 @@ impl Parser {
                     // Otherwise, unwrap and parse the inner rule
                     let inner_pair = inner.next().unwrap();
                     match inner_pair.as_rule() {
-                        Rule::literal => self.parse_expr(inner_pair),
                         Rule::identifier => Ok(Expr::Identifier(
                             inner_pair.as_str().to_string(),
                             TypeId::default(),
                         )),
-                        Rule::function_call_expr
+                        Rule::literal
+                        | Rule::function_call_expr
                         | Rule::array_literal
                         | Rule::struct_init
                         | Rule::union_init
                         | Rule::tuple_literal
                         | Rule::if_expr
                         | Rule::range_expr
                         | Rule::string
-                        | Rule::expr => self.parse_expr(inner_pair),
-                        Rule::unary => self.parse_expr(inner_pair),
+                        | Rule::expr
+                        | Rule::unary => self.parse_expr(inner_pair),
                         _ => Err(parse_error!(
                             "Unexpected primary inner rule: {:?}",
                             inner_pair.as_rule()
@@ -429,8 +429,7 @@ impl Parser {
                 })
             }
             other => Err(CompilationError::ParseError(format!(
-                "Unexpected expr rule: {:?}",
-                other
+                "Unexpected expr rule: {other:?}"
             ))),
         }
     }

kitlang/src/codegen/symbols.rs

@@ -4,9 +4,9 @@ use std::collections::HashMap;
 /// Symbol table for tracking variable and function types during inference.
 ///
 /// Currently uses a flat scope (no nesting). Variables and functions are tracked
-/// by their names and their TypeIds.
+/// by their names and their `TypeId`s.
 pub struct SymbolTable {
-    /// Maps variable names to their inferred TypeIds.
+    /// Maps variable names to their inferred `TypeId`s.
     vars: HashMap<String, TypeId>,
 
     /// Maps function names to their signatures (parameter types, return type).