function call codegen and started Blossom

Author: kiahjh

Cargo.lock

@@ -5,7 +5,18 @@ edition = "2024"
 
 [dependencies]
 clap = { version = "4.5.38", features = ["derive"] }
+colored = "3.0.0"
 pretty_assertions = "1.4.1"
 
 [dev-dependencies]
 insta = { version = "1.43.1", features = ["glob"] }
+
+[lints.clippy]
+pedantic = "warn"
+nursery = "warn"
+perf = "warn"
+correctness = "warn"
+suspicious = "warn"
+style = "warn"
+complexity = "warn"
+cargo = "warn"

Cargo.toml

@@ -0,0 +1,14 @@
+## Adds two integers
+add :: fun (~x: Int, to y: Int) -> Int: x + y
+
+## Subtracts two integers
+subtract :: fun (~x: Int, from y: Int) -> Int: y - x
+
+## Multiplies two integers
+multiply :: fun (~x: Int, with y: Int) -> Int: x * y
+
+## Divides two integers
+divide :: fun (~x: Int, by y: Int) -> Int: x / y
+
+## The ratio of the circumference to the diameter of a circle
+pi :: 3

cool_app/lib/math.lv

@@ -0,0 +1,4 @@
+use lib/math
+use num.(get_three, get_four)
+
+main :: fun () -> Int: math.add(2, to: get_three())

cool_app/main.lv

@@ -0,0 +1 @@
+get_three :: fun () -> Int: 3

cool_app/num.lv

@@ -1,2 +0,0 @@
-- all about function call!!
-- fix that idiv bug that rsahwe pointed out

examples/test.asm

@@ -0,0 +1,129 @@
+// lovingly named by japi (July 24, 2025)
+
+use crate::parser;
+use std::{error::Error, fs, path::PathBuf};
+
+pub mod printer;
+
+pub struct Blossom {}
+
+impl Blossom {
+    pub fn build(path: String) -> Result<(), Box<dyn Error>> {
+        let path_buf = PathBuf::from(path);
+        let file_tree = collect_files(path_buf)?;
+        let lovely_files = file_tree
+            .filter(&|name, _| name.ends_with(".lv"))
+            .expect("Expected a directory");
+        let parsed_lovely_files =
+            lovely_files.try_map(&|s| parser::Parser::new(s).parse().map_err(|e| e.into()))?;
+
+        println!("Building your project...");
+
+        Ok(())
+    }
+}
+
+fn collect_files(path: PathBuf) -> Result<FileTreeNode<String>, Box<dyn Error>> {
+    if !path.is_dir() {
+        printer::error("That's not a directory you silly!");
+        return Err("Not a directory".into());
+    }
+    let Ok(dir) = path.read_dir() else {
+        printer::error("Uh for some reason we couldn't read the directory. Not really sure why.");
+        return Err("Failed to read directory".into());
+    };
+    let Ok(dir) = dir.collect::<Result<Vec<_>, _>>() else {
+        printer::error(
+            "You know, today just really isn't your day is it. Something awful happened, and I have no idea what it was.",
+        );
+        return Err("Failed to read directory".into());
+    };
+
+    let mut children = vec![];
+
+    for dir_entry in dir {
+        if dir_entry.path().is_dir() {
+            children.push(collect_files(dir_entry.path())?);
+        } else {
+            let contents = fs::read_to_string(dir_entry.path())?;
+            let name = dir_entry.path().to_str().unwrap().to_string();
+            children.push(FileTreeNode::File { name, contents })
+        }
+    }
+
+    Ok(FileTreeNode::Directory {
+        children,
+        name: path
+            .to_str()
+            .expect("Weird file name, it made me uncomfortable.")
+            .into(),
+    })
+}
+
+enum FileTreeNode<T> {
+    Directory {
+        name: String,
+        children: Vec<FileTreeNode<T>>,
+    },
+    File {
+        name: String,
+        contents: T,
+    },
+}
+
+impl<T> FileTreeNode<T> {
+    fn filter<F>(&self, f: &F) -> Option<FileTreeNode<T>>
+    where
+        F: Fn(&String, &T) -> bool,
+        T: Clone,
+    {
+        match self {
+            FileTreeNode::Directory { children, name } => Some(FileTreeNode::Directory {
+                name: name.clone(),
+                children: children.iter().filter_map(|c| c.filter(f)).collect(),
+            }),
+            FileTreeNode::File { name, contents } => {
+                if f(name, contents) {
+                    Some(FileTreeNode::File {
+                        name: name.clone(),
+                        contents: contents.clone(),
+                    })
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    fn map<U>(&self, f: &impl Fn(&T) -> U) -> FileTreeNode<U> {
+        match self {
+            Self::Directory { name, children } => FileTreeNode::Directory {
+                name: name.clone(),
+                children: children.iter().map(|c| FileTreeNode::map(c, f)).collect(),
+            },
+            Self::File { name, contents } => FileTreeNode::File {
+                name: name.clone(),
+                contents: f(contents),
+            },
+        }
+    }
+
+    fn try_map<U>(
+        &self,
+        f: &impl Fn(&T) -> Result<U, Box<dyn Error>>,
+    ) -> Result<FileTreeNode<U>, Box<dyn Error>> {
+        match self {
+            Self::Directory { name, children } => Ok(FileTreeNode::Directory {
+                name: name.clone(),
+                children: children
+                    .iter()
+                    .map(|c| c.try_map(f))
+                    .collect::<Result<Vec<_>, _>>()?,
+            }),
+            Self::File { name, contents } => Ok(FileTreeNode::File {
+                name: name.clone(),
+                contents: f(contents)?,
+            }),
+        }
+    }
+}

examples/test.lv

@@ -0,0 +1,5 @@
+use colored::Colorize;
+
+pub fn error(text: &str) {
+    eprintln!("{}", text.red());
+}