A31 Feature: Add linter Clippy

.gitignore

@@ -1,7 +1,7 @@
 /target
 
 # Test files
-test.amber
+test.ab
 test.sh
 
 # MacOS

Cargo.toml

@@ -6,6 +6,6 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heraclitus-compiler = "1.3.0"
+heraclitus-compiler = "1.3.2"
 similar-string = "1.4.2"
 colored = "2.0.0"

build.ab

@@ -7,7 +7,12 @@ let linux_x64 = 'x86_64-unknown-linux-musl'
 $test -f "Cargo.toml" > /dev/null$
 
 if $echo \$?$ == '0' {
-    $cargo build --release --target {macos_arm} --target {linux_arm} --target {macos_x64} --target {linux_x64}$
+    $cargo build --release
+        --target {macos_arm}
+        --target {linux_arm}
+        --target {macos_x64}
+        --target {linux_x64}
+    $
     # Move ambers to the release directory
     $mv target/aarch64-apple-darwin/release/amber target/release/amber_macos_aarch64$
     $mv target/aarch64-unknown-linux-musl/release/amber target/release/amber_linux_aarch64$

src/cli/cli.rs → src/cli/cli_interface.rs

@@ -19,15 +19,21 @@ pub struct CLI {
     ext: String
 }
 
+impl Default for CLI {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl CLI {
     pub fn new() -> Self {
         CLI {
             args: vec![],
             flags: FlagRegistry::new(),
-            name: format!("Amber"),
-            exe_name: format!("amber"),
-            version: format!("{}", env!("CARGO_PKG_VERSION")),
-            ext: format!(".amber")
+            name: "Amber".to_string(),
+            exe_name: "amber".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+            ext: ".amber".to_string()
         }
     }
 
@@ -40,7 +46,7 @@ impl CLI {
         if self.flags.flag_triggered("-e") {
             match self.flags.get_flag("-e").unwrap().value.clone() {
                 Some(code) => {
-                    let translation = self.compile(code.clone(), None);
+                    let translation = self.compile(code, None);
                     self.execute(translation);
                 },
                 None => {
@@ -55,14 +61,14 @@ impl CLI {
             let input = self.args[1].clone();
             match self.read_file(input.clone()) {
                 Ok(code) => {
-                    let code = self.compile(code, Some(input.clone()));
+                    let code = self.compile(code, Some(input));
                     // Save to the output file
                     if self.args.len() >= 3 {
                         let output = self.args[2].clone();
                         match fs::File::create(output.clone()) {
                             Ok(mut file) => {
                                 write!(file, "{}", code).unwrap();
-                                self.set_file_permission(&file, output.clone());
+                                self.set_file_permission(&file, output);
 
                             },
                             Err(err) => {
@@ -120,14 +126,14 @@ impl CLI {
         let mut block = block::Block::new();
         cc.load(code.clone());
         if let Ok(tokens) = cc.tokenize() {
-            let mut meta = ParserMetadata::new(tokens, path.clone(), Some(code.clone()));
+            let mut meta = ParserMetadata::new(tokens, path, Some(code));
             if let Ok(()) = block.parse(&mut meta) {
                 let mut meta = TranslateMetadata::new();
-                return format!("{}", block.translate(&mut meta));
+                return block.translate(&mut meta);
             }
-            return format!("[parsing err]")
+            return "[parsing err]".to_string()
         }
-        format!("[lexing err]")
+        "[lexing err]".to_string()
     }
 
     fn execute(&self, code: String) {

src/cli/flag_registry.rs

@@ -20,6 +20,12 @@ pub struct FlagRegistry {
     flags: HashMap<String, Flag>
 }
 
+impl Default for FlagRegistry {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl FlagRegistry {
     #[inline]
     pub fn new() -> Self {

src/cli/mod.rs

@@ -1,9 +1,9 @@
 pub mod flag_registry;
-pub mod cli;
+pub mod cli_interface;
 
 #[cfg(test)]
 mod tests {
-    use super::cli::CLI;
+    use super::cli_interface::CLI;
 
     #[test]
     fn hello_world() {

src/main.rs

@@ -3,7 +3,7 @@ mod rules;
 mod utils;
 mod translate;
 pub mod cli;
-use cli::cli::CLI;
+use cli::cli_interface::CLI;
 
 fn main() { 
     let mut cli = CLI::new();

src/modules/block.rs

@@ -1,7 +1,7 @@
 use heraclitus_compiler::prelude::*;
 use crate::{utils::{metadata::ParserMetadata, error::get_error_logger, TranslateMetadata}};
 use crate::translate::module::TranslateModule;
-use super::statement::statement::Statement;
+use super::statement::st::Statement;
 
 #[derive(Debug)]
 pub struct Block {
@@ -28,25 +28,20 @@ impl SyntaxModule<ParserMetadata> for Block {
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
         meta.var_mem.push_scope();
-        loop {
-            match meta.get_current_token() {
-                Some(token) => {
-                    // Handle the end of line or command
-                    if ["\n", ";"].contains(&token.word.as_str()) {
-                        meta.increment_index();
-                        continue;
-                    }
-                    // Handle comments
-                    if token.word.starts_with("#") {
-                        meta.increment_index();
-                        continue
-                    }
-                    // Handle block end
-                    else if token.word == "}" {
-                        break;
-                    }
-                }
-                None => break
+        while let Some(token) = meta.get_current_token() {
+            // Handle the end of line or command
+            if ["\n", ";"].contains(&token.word.as_str()) {
+                meta.increment_index();
+                continue;
+            }
+            // Handle comments
+            if token.word.starts_with('#') {
+                meta.increment_index();
+                continue
+            }
+            // Handle block end
+            else if token.word == "}" {
+                break;
             }
             let mut statemant = Statement::new();
             if let Err(details) = statemant.parse(meta) {

src/modules/command/expr.rs

@@ -39,6 +39,6 @@ impl TranslateModule for CommandExpr {
         let interps = self.interps.iter()
             .map(|item| item.translate(meta))
             .collect::<Vec<String>>();
-        format!("$({})", translate_interpolated_region(self.strings.clone(), interps.clone(), false))
+        format!("$({})", translate_interpolated_region(self.strings.clone(), interps, false))
     }
 }

src/modules/command/statement.rs

@@ -39,6 +39,6 @@ impl TranslateModule for CommandStatement {
         let interps = self.interps.iter()
             .map(|item| item.translate(meta))
             .collect::<Vec<String>>();
-        format!("{}", translate_interpolated_region(self.strings.clone(), interps.clone(), false))
+        translate_interpolated_region(self.strings.clone(), interps, false)
     }
 }

src/modules/conditions/ifchain.rs

@@ -30,16 +30,16 @@ impl SyntaxModule<ParserMetadata> for IfChain {
             let mut block = Block::new();
             cond.cannot_fail();
             // Handle comments and empty lines
-            if let Ok(_) = token_by(meta, |token| token.starts_with("#") || token.starts_with("\n")) {
+            if token_by(meta, |token| token.starts_with('#') || token.starts_with('\n')).is_ok() {
                 continue
             }
             // Handle else keyword
-            if let Ok(_) = token(meta, "else") {
+            if token(meta, "else").is_ok() {
                 is_else = true;
                 break
             }
             // Handle end of the if chain
-            if let Err(_) = syntax(meta, &mut cond) {
+            if syntax(meta, &mut cond).is_err() {
                 break
             }
             token(meta, "{")?;
@@ -75,10 +75,10 @@ impl TranslateModule for IfChain {
             }
         }
         if let Some(false_block) = &self.false_block {
-            result.push(format!("else"));
+            result.push("else".to_string());
             result.push(false_block.translate(meta));
         }
-        result.push(format!("fi"));
+        result.push("fi".to_string());
         result.join("\n")
     }
 }

src/modules/conditions/ifcond.rs

@@ -31,7 +31,7 @@ impl SyntaxModule<ParserMetadata> for IfCondition {
         syntax(meta, &mut *self.true_block)?;
         token(meta, "}")?;
         // Parse false block
-        if let Ok(_) = token(meta, "else") {
+        if token(meta, "else").is_ok() {
             token(meta, "{")?;
             let mut false_block = Box::new(Block::new());
             syntax(meta, &mut *false_block)?;
@@ -48,10 +48,10 @@ impl TranslateModule for IfCondition {
         result.push(format!("if [ {} != 0 ]; then", self.expr.translate(meta)));
         result.push(self.true_block.translate(meta));
         if let Some(false_block) = &self.false_block {
-            result.push(format!("else"));
+            result.push("else".to_string());
             result.push(false_block.translate(meta));
         }
-        result.push(format!("fi"));
+        result.push("fi".to_string());
         result.join("\n")
     }
 }

src/modules/expression/binop/add.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Add {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "+")?;
+        parse_left_expr(meta, &mut self.left, "+")?;
         let tok = meta.get_current_token();
         token(meta, "+")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/and.rs

@@ -29,7 +29,7 @@ impl SyntaxModule<ParserMetadata> for And {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "and")?;
+        parse_left_expr(meta, &mut self.left, "and")?;
         let tok = meta.get_current_token();
         token(meta, "and")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/div.rs

@@ -27,7 +27,7 @@ impl SyntaxModule<ParserMetadata> for Div {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "/")?;
+        parse_left_expr(meta, &mut self.left, "/")?;
         let tok = meta.get_current_token();
         token(meta, "/")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/eq.rs

@@ -29,7 +29,7 @@ impl SyntaxModule<ParserMetadata> for Eq {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "==")?;
+        parse_left_expr(meta, &mut self.left, "==")?;
         let tok = meta.get_current_token();
         token(meta, "==")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/ge.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Ge {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, ">=")?;
+        parse_left_expr(meta, &mut self.left, ">=")?;
         let tok = meta.get_current_token();
         token(meta, ">=")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/gt.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Gt {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, ">")?;
+        parse_left_expr(meta, &mut self.left, ">")?;
         let tok = meta.get_current_token();
         token(meta, ">")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/le.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Le {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "<=")?;
+        parse_left_expr(meta, &mut self.left, "<=")?;
         let tok = meta.get_current_token();
         token(meta, "<=")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/lt.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Lt {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "<")?;
+        parse_left_expr(meta, &mut self.left, "<")?;
         let tok = meta.get_current_token();
         token(meta, "<")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/mod.rs

@@ -16,7 +16,7 @@ pub mod eq;
 pub mod neq;
 
 
-pub fn expression_arms_of_type(meta: &mut ParserMetadata, left: &Box<Expr>, right: &Box<Expr>, kind: Type, tok_pos: Option<Token>, message: &str) {
+pub fn expression_arms_of_type(meta: &mut ParserMetadata, left: &Expr, right: &Expr, kind: Type, tok_pos: Option<Token>, message: &str) {
     if ![left.get_type(), right.get_type()].iter().all(|item| *item == kind) {
         get_error_logger(meta, ErrorDetails::from_token_option(tok_pos))
             .attach_message(message)
@@ -25,7 +25,7 @@ pub fn expression_arms_of_type(meta: &mut ParserMetadata, left: &Box<Expr>, righ
     }
 }
 
-pub fn expression_arms_of_same_type(meta: &mut ParserMetadata, left: &Box<Expr>, right: &Box<Expr>, tok_pos: Option<Token>, message: &str) {
+pub fn expression_arms_of_same_type(meta: &mut ParserMetadata, left: &Expr, right: &Expr, tok_pos: Option<Token>, message: &str) {
     if left.get_type() != right.get_type() {
         get_error_logger(meta, ErrorDetails::from_token_option(tok_pos))
             .attach_message(message)

src/modules/expression/binop/mul.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Mul {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "*")?;
+        parse_left_expr(meta, &mut self.left, "*")?;
         let tok = meta.get_current_token();
         token(meta, "*")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/neq.rs

@@ -29,7 +29,7 @@ impl SyntaxModule<ParserMetadata> for Neq {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "!=")?;
+        parse_left_expr(meta, &mut self.left, "!=")?;
         let tok = meta.get_current_token();
         token(meta, "!=")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/or.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Or {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "or")?;
+        parse_left_expr(meta, &mut self.left, "or")?;
         let tok = meta.get_current_token();
         token(meta, "or")?;
         syntax(meta, &mut *self.right)?;

src/modules/expression/binop/sub.rs

@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Sub {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        parse_left_expr(meta, &mut *self.left, "-")?;
+        parse_left_expr(meta, &mut self.left, "-")?;
         let tok = meta.get_current_token();
         token(meta, "-")?;
         syntax(meta, &mut *self.right)?;