fix: tasks 1-6 bug fixes, fmt crate, and stdlib return type shapes

crates/fmt/src/commands.rs

@@ -6,6 +6,7 @@ use code_lang::{
     parser::parser::Parser,
 };
 
+use crate::formatter::Formatter;
 use crate::lint_rules::{
     ConstReassignment, DeadCode, EmptyBlock, LintFix, LintRule, LintSeverity, ShadowedBinding,
     UndefinedVariable, UnusedImport, UnusedVariable,
@@ -217,3 +218,56 @@ fn apply_fixes(path: &PathBuf, src: String, fixes: Vec<&LintFix>) {
         eprintln!("{}: failed to write fixes: {}", path.display(), e);
     }
 }
+
+
+pub fn format_file(files: &[PathBuf], stdout:bool) -> Result<()> {
+    for file in files {
+        let ext_ok = file
+            .extension()
+            .and_then(|e| e.to_str())
+            .map(|e| e.eq_ignore_ascii_case("cl"))
+            .unwrap_or(false);
+
+        if !ext_ok {
+            bail!("expect a .cl file, got: {}", file.display())
+        }
+
+        let src = match fs::read_to_string(file) {
+            Ok(s) => s,
+            Err(e) => {
+                eprintln!("{}: cannot read file: {}", file.display(), e);
+                continue;
+            }
+        };
+
+        let lines: Vec<&str> = src.lines().collect();
+        let lexer = Lexer::new(src.clone());
+        let mut parser = Parser::new(lexer);
+        let program = parser.parse_program();
+
+        //formatter
+        if !parser.errors.is_empty() {
+            for err in &parser.errors {
+                print_caret(
+                    &lines,
+                    file,
+                    err.line,
+                    err.column,
+                    &LintSeverity::Error,
+                    None,
+                    &err.message,
+                );
+            }
+        }  
+
+        let formatted = Formatter::format(&program);
+        if stdout {
+            print!("{:?}", formatted)
+        } else if formatted != src {
+            fs::write(file, formatted)?;
+            println!("{}: formatted", file.display());
+        }
+    }
+
+    Ok(())
+}

crates/fmt/src/formatter.rs

@@ -0,0 +1,14 @@
+use code_lang::ast::ast::{Expression, Program, Statement};
+
+pub struct Formatter {
+    indent_level: usize,
+    output: String
+}
+
+const IDENT:&str = "    "; // 4 spaces
+
+impl Formatter {
+    pub fn format(program: &Program){ }
+    pub fn fmt_statement(&mut self, stmt:&Statement){}
+    pub fn fmt_expression(&mut self, expr:&Expression){}
+}

crates/fmt/src/lint_rules.rs

@@ -4,7 +4,7 @@ use code_lang::{
     analysis::scope::ScopeTree,
     ast::{
         ast::{Expression, LetPattern, Statement},
-        walk::{Visitor, walk_statement},
+        walk::{Visitor, walk_expression, walk_statement},
     },
     token::token::TokenType,
 };
@@ -170,6 +170,10 @@ impl Visitor for ShadowedBinding {
     fn visit_const(&mut self, pattern: &LetPattern, _value: &Expression, line: usize, col: usize) {
         self.register_pattern(pattern, line, col);
     }
+
+    fn visit_expression(&mut self, expr: &Expression) {
+
+    }
 }
 
 impl LintRule for ShadowedBinding {
@@ -215,6 +219,21 @@ impl Visitor for UnusedVariable {
         }
     }
 
+    fn visit_const(
+        &mut self,
+        pattern: &LetPattern,
+        _value: &Expression,
+        line: usize,
+        col: usize,
+    )
+    {
+        match pattern {
+            LetPattern::Array(names) => for name in names { self.declared.insert(name.to_string(), (line, col, false));},
+            LetPattern::Hash(pairs) => for (_, alias) in pairs  { self.declared.insert(alias.to_string(), (line, col, false));},
+            LetPattern::Ident(n) => { self.declared.insert(n.to_string(), (line,col, false));}
+        }
+    }
+
     fn visit_ident(&mut self, value: &str, _line: usize, _col: usize) {
         self.used.insert(value.to_string());
     }
@@ -390,6 +409,8 @@ impl Visitor for DeadCode {
 
             self.returned = saved;
         }
+
+        walk_statement(self, stmt);
     }
 }
 
@@ -506,6 +527,8 @@ impl Visitor for EmptyBlock {
                 fix: None,
             });
         }
+
+        walk_expression(self, expr);
     }
 }
 
@@ -557,6 +580,17 @@ impl Visitor for UndefinedVariable {
             });
         }
     }
+
+    fn visit_member(
+        &mut self,
+        object: &Expression,
+        _property: &Expression,
+        _line: usize,
+        _col: usize,
+    )
+    {
+        self.visit_expression(object);
+    }
 }
 
 impl LintRule for UndefinedVariable {

crates/fmt/src/main.rs

@@ -1,12 +1,13 @@
 mod commands;
 mod lint_rules;
 mod util;
+mod formatter;
 use std::path::PathBuf;
 
 use anyhow::Result;
 use clap::{Parser, Subcommand};
 
-use crate::commands::{check_file, lint_file};
+use crate::commands::{check_file, format_file, lint_file};
 
 #[derive(Parser)]
 #[command(name = "code-lang-fmt")]
@@ -28,6 +29,13 @@ enum Commands {
         #[arg(long)]
         fix: bool,
     },
+
+    Format {
+        files: Vec<PathBuf>,
+
+        #[arg(long)]
+        stdout:bool
+    }
 }
 
 fn main() -> Result<()> {
@@ -39,6 +47,9 @@ fn main() -> Result<()> {
         Some(Commands::Lint { files, fix }) => {
             lint_file(&files, fix)?;
         }
+        Some(Commands::Format { files, stdout }) => {
+            format_file(&files, stdout)?;
+        },
         None => {}
     }
     Ok(())