style: apply rustfmt and add clippy lint suppressions (#252)

- Reformat all source files using rustfmt for consistent indentation and code style.
- Add comprehensive lint suppression blocks (#![allow(...)]) to lexer, parser, and llvm_temporary modules to ignore dead code and specific clippy warnings.
- Reorganize and clean up imports across the project.
- Refactor minor logic for better idiomatic Rust (e.g., replacing `is_digit(10)` with `is_ascii_digit()` and `nth(0)` with `next()`).
- Update match arms and multi-line function calls for improved readability.

Signed-off-by: LunaStev <luna@lunastev.org>

Author: LunaStev

front/error/src/error.rs

@@ -8,35 +8,35 @@ pub enum WaveErrorKind {
     InvalidString(String),
     UnterminatedString,
     UnterminatedComment,
-    
+
     // Parser errors
     SyntaxError(String),
     UnexpectedEndOfFile,
     InvalidExpression(String),
     InvalidStatement(String),
     InvalidType(String),
-    
+
     // Import/Module errors
     ModuleNotFound(String),
     ImportError(String),
     CircularImport(String),
-    
+
     // Type checking errors
     TypeMismatch { expected: String, found: String },
     UndefinedVariable(String),
     UndefinedFunction(String),
     InvalidFunctionCall(String),
     InvalidAssignment(String),
-    
+
     // Standard library errors
     StandardLibraryNotAvailable,
     UnknownStandardLibraryModule(String),
     VexIntegrationRequired(String),
-    
+
     // Compilation errors
     CompilationFailed(String),
     LinkingFailed(String),
-    
+
     // I/O errors
     FileNotFound(String),
     FileReadError(String),
@@ -67,7 +67,13 @@ pub enum ErrorSeverity {
 }
 
 impl WaveError {
-    pub fn new(kind: WaveErrorKind, message: impl Into<String>, file: impl Into<String>, line: usize, column: usize) -> Self {
+    pub fn new(
+        kind: WaveErrorKind,
+        message: impl Into<String>,
+        file: impl Into<String>,
+        line: usize,
+        column: usize,
+    ) -> Self {
         Self {
             kind,
             message: message.into(),
@@ -117,24 +123,39 @@ impl WaveError {
     pub fn stdlib_requires_vex(module: &str, file: &str, line: usize, column: usize) -> Self {
         Self::new(
             WaveErrorKind::VexIntegrationRequired(module.to_string()),
-            format!("standard library module 'std::{}' requires Vex package manager", module),
+            format!(
+                "standard library module 'std::{}' requires Vex package manager",
+                module
+            ),
             file,
             line,
             column,
         )
         .with_help("Wave compiler in standalone mode only supports low-level system programming")
         .with_suggestion("Use 'vex build' or 'vex run' to access standard library modules")
-        .with_suggestion(format!("Remove the import for 'std::{}' to use Wave in low-level mode", module))
+        .with_suggestion(format!(
+            "Remove the import for 'std::{}' to use Wave in low-level mode",
+            module
+        ))
     }
 
     /// Create a type mismatch error with detailed information
-    pub fn type_mismatch(expected: &str, found: &str, file: &str, line: usize, column: usize) -> Self {
+    pub fn type_mismatch(
+        expected: &str,
+        found: &str,
+        file: &str,
+        line: usize,
+        column: usize,
+    ) -> Self {
         Self::new(
-            WaveErrorKind::TypeMismatch { 
-                expected: expected.to_string(), 
-                found: found.to_string() 
+            WaveErrorKind::TypeMismatch {
+                expected: expected.to_string(),
+                found: found.to_string(),
             },
-            format!("mismatched types: expected `{}`, found `{}`", expected, found),
+            format!(
+                "mismatched types: expected `{}`, found `{}`",
+                expected, found
+            ),
             file,
             line,
             column,
@@ -168,15 +189,26 @@ impl WaveError {
 
         // Main error message
         eprintln!("{}: {}", severity_str, self.message.bold());
-        
+
         // Location
-        eprintln!("  {} {}:{}:{}", "-->".blue().bold(), self.file, self.line, self.column);
+        eprintln!(
+            "  {} {}:{}:{}",
+            "-->".blue().bold(),
+            self.file,
+            self.line,
+            self.column
+        );
         eprintln!("   {}", "|".blue().bold());
 
         // Source code with highlighting
         if let Some(source_line) = &self.source {
-            eprintln!("{:>3} {} {}", self.line.to_string().blue().bold(), "|".blue().bold(), source_line);
-            
+            eprintln!(
+                "{:>3} {} {}",
+                self.line.to_string().blue().bold(),
+                "|".blue().bold(),
+                source_line
+            );
+
             // Arrow pointing to the error
             let spaces = " ".repeat(self.column.saturating_sub(1));
             let arrow = match self.severity {
@@ -185,9 +217,15 @@ impl WaveError {
                 ErrorSeverity::Note => "^".cyan().bold(),
                 ErrorSeverity::Help => "^".green().bold(),
             };
-            
+
             if let Some(label) = &self.label {
-                eprintln!("   {} {}{} {}", "|".blue().bold(), spaces, arrow, label.dimmed());
+                eprintln!(
+                    "   {} {}{} {}",
+                    "|".blue().bold(),
+                    spaces,
+                    arrow,
+                    label.dimmed()
+                );
             } else {
                 eprintln!("   {} {}{}", "|".blue().bold(), spaces, arrow);
             }
@@ -197,16 +235,31 @@ impl WaveError {
 
         // Additional information
         if let Some(note) = &self.note {
-            eprintln!("   {} {}: {}", "=".blue().bold(), "note".cyan().bold(), note);
+            eprintln!(
+                "   {} {}: {}",
+                "=".blue().bold(),
+                "note".cyan().bold(),
+                note
+            );
         }
 
         if let Some(help) = &self.help {
-            eprintln!("   {} {}: {}", "=".blue().bold(), "help".green().bold(), help);
+            eprintln!(
+                "   {} {}: {}",
+                "=".blue().bold(),
+                "help".green().bold(),
+                help
+            );
         }
 
         // Suggestions
         for suggestion in &self.suggestions {
-            eprintln!("   {} {}: {}", "=".blue().bold(), "suggestion".green().bold(), suggestion);
+            eprintln!(
+                "   {} {}: {}",
+                "=".blue().bold(),
+                "suggestion".green().bold(),
+                suggestion
+            );
         }
     }
 
@@ -218,20 +271,28 @@ impl WaveError {
             }
             error.display();
         }
-        
+
         if errors.len() > 1 {
-            let error_count = errors.iter().filter(|e| matches!(e.severity, ErrorSeverity::Error)).count();
-            let warning_count = errors.iter().filter(|e| matches!(e.severity, ErrorSeverity::Warning)).count();
-            
+            let error_count = errors
+                .iter()
+                .filter(|e| matches!(e.severity, ErrorSeverity::Error))
+                .count();
+            let warning_count = errors
+                .iter()
+                .filter(|e| matches!(e.severity, ErrorSeverity::Warning))
+                .count();
+
             eprintln!();
             if error_count > 0 {
-                eprintln!("error: aborting due to {} previous error{}", 
-                    error_count, 
+                eprintln!(
+                    "error: aborting due to {} previous error{}",
+                    error_count,
                     if error_count == 1 { "" } else { "s" }
                 );
             }
             if warning_count > 0 {
-                eprintln!("warning: {} warning{} emitted", 
+                eprintln!(
+                    "warning: {} warning{} emitted",
                     warning_count,
                     if warning_count == 1 { "" } else { "s" }
                 );
@@ -243,4 +304,4 @@ impl WaveError {
     pub fn is_fatal(&self) -> bool {
         matches!(self.severity, ErrorSeverity::Error)
     }
-}
+}