Bump version

CLI improvements, module system fixes, project scaffolding, and bug fixes

Cargo.lock

@@ -476,11 +476,12 @@ dependencies = [
 
 [[package]]
 name = "mist-analyzer"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 dependencies = [
  "cargo_metadata",
  "dashmap 6.1.0",
  "heck",
+ "mist-api",
  "mist-codegen",
  "mist-parser",
  "pest",
@@ -494,7 +495,7 @@ dependencies = [
 
 [[package]]
 name = "mist-api"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 dependencies = [
  "cargo_metadata",
  "mist-codegen",
@@ -506,7 +507,7 @@ dependencies = [
 
 [[package]]
 name = "mist-codegen"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 dependencies = [
  "bytecount",
  "mist-parser",
@@ -514,15 +515,16 @@ dependencies = [
 
 [[package]]
 name = "mist-lang"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 dependencies = [
  "mist-analyzer",
  "mist-api",
+ "toml",
 ]
 
 [[package]]
 name = "mist-parser"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 dependencies = [
  "pest",
  "pest_derive",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-lang"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 edition = "2024"
 description = "The Mist programming language compiler"
 license = "Apache-2.0"
@@ -18,6 +18,7 @@ include = [
 [dependencies]
 mist-analyzer = { workspace = true }
 mist-api = { workspace = true }
+toml = "1.1.2"
 
 [workspace]
 members = [
@@ -32,10 +33,10 @@ exclude = [
 ]
 
 [workspace.dependencies]
-mist-parser = { path = "crates/parser", version = "0.3.7-alpha.0" }
-mist-analyzer = { path = "crates/analyzer", version = "0.3.7-alpha.0" }
-mist-codegen = { path = "crates/codegen", version = "0.3.7-alpha.0" }
-mist-api = { path = "crates/mist-api", version = "0.3.7-alpha.0" }
+mist-parser = { path = "crates/parser", version = "0.3.8-alpha.0" }
+mist-analyzer = { path = "crates/analyzer", version = "0.3.8-alpha.0" }
+mist-codegen = { path = "crates/codegen", version = "0.3.8-alpha.0" }
+mist-api = { path = "crates/mist-api", version = "0.3.8-alpha.0" }
 
 [[bin]]
 name = "mist"

Mist.toml

@@ -1,2 +1,3 @@
 package = "main.mist"
 packages = []
+include = ["crates/*"]

crates/analyzer/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-analyzer"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 edition = "2024"
 description = "The Mist programming language Analyzer LSP"
 license = "Apache-2.0"
@@ -9,6 +9,7 @@ keywords = ["language-server", "language", "mist"]
 categories = ["compilers"]
 
 [dependencies]
+mist-api = { workspace = true }
 mist-parser = { workspace = true }
 mist-codegen = { workspace = true }
 pest = "2.8.6"

crates/analyzer/src/lib.rs

@@ -7,18 +7,22 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicU64, Ordering};
 
 use heck::ToSnakeCase;
+use mist_api::transpiler::MistConfig;
 use mist_parser::MistFmtConfig;
 use mist_parser::error::ParseError;
+use mist_parser::parse_module;
 use mist_parser::rev_mapper::{Mapping, MistMap, RustMap};
 use ropey::Rope;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
 use serde_json::Value;
 use tokio::sync::Mutex;
 use tower_lsp::lsp_types::{self, *};
 use tower_lsp::{Client, LanguageServer, LspService, Server};
 
 use crate::rust_analyzer::RustAnalyzer;
-use crate::transpiler::{TranspileError, format_mist, transpile_mist, transpile_mist_no_sem};
+use crate::transpiler::{
+    TranspileError, TranspiledFile, format_mist, transpile_mist, transpile_mist_no_sem,
+};
 
 static MARKER_COUNTER: AtomicU64 = AtomicU64::new(0);
 
@@ -519,8 +523,9 @@ impl Backend {
             Some(p) => p.clone(),
             None => return String::new(),
         };
-        let src_root = ws.join("src");
-        let package_mist = read_mist_package(&ws);
+        let crate_root = find_crate_root(mist_path).unwrap_or(ws);
+        let src_root = crate_root.join("src");
+        let package_mist = read_mist_package(&crate_root);
         let docs = self.documents.lock().await;
         let mod_decls = compute_mod_decls(&docs, &src_root, &package_mist);
         mod_decls.get(mist_path).cloned().unwrap_or_default()
@@ -547,7 +552,7 @@ impl Backend {
         mist_path: &Path,
         source: &str,
         extra_mod_decl: &str,
-    ) {
+    ) -> Option<TranspiledFile> {
         let transpiled = match transpile_mist(mist_path, source, extra_mod_decl) {
             Ok(t) => t,
             Err(e) => {
@@ -556,7 +561,7 @@ impl Backend {
                 if let Some(uri) = clean_lsp_url(mist_path) {
                     self.publish_diagnostics(uri, diag).await;
                 }
-                return;
+                return None;
             }
         };
 
@@ -577,28 +582,28 @@ impl Backend {
                 let _ = ra.did_open(rust_uri, &transpiled.rust_content).await;
             }
 
-            map.insert(transpiled.rust_path, transpiled.mapping);
+            map.insert(transpiled.rust_path.clone(), transpiled.mapping.clone());
             self.last_rust_contents
                 .lock()
                 .await
-                .insert(mist_path.to_path_buf(), transpiled.rust_content);
+                .insert(mist_path.to_path_buf(), transpiled.rust_content.clone());
         }
 
         // Clear any previous diagnostics — transpile succeeded.
         if let Some(mist_uri) = clean_lsp_url(mist_path) {
             self.publish_diagnostics(mist_uri, vec![]).await;
         }
+
+        Some(transpiled)
     }
 
-    async fn rebuild_module_tree(&self) {
+    async fn rebuild_module_tree(&self, persist: bool) {
         let ws = match &*self.workspace_folder.lock().await {
             Some(p) => p.clone(),
             None => return,
         };
-        let src_root = ws.join("src");
-        let package_mist = read_mist_package(&ws);
 
-        self.ensure_implicit_packages(&src_root).await;
+        self.ensure_implicit_packages().await;
 
         // Collect sources first to avoid holding locks during transpile
         let sources: Vec<(PathBuf, String, String)> = {
@@ -606,25 +611,72 @@ impl Backend {
             if docs.is_empty() {
                 return;
             }
+            let crate_roots = collect_crate_roots(&docs, &ws);
+            let mut result = Vec::new();
+            for crate_root in &crate_roots {
+                let src_root = crate_root.join("src");
+                let package_mist = read_mist_package(crate_root);
                 let mod_decls = compute_mod_decls(&docs, &src_root, &package_mist);
-            mod_decls
-                .into_iter()
-                .filter(|(_, decl)| !decl.is_empty())
-                .filter_map(|(path, decl)| docs.get(&path).map(|r| (path, r.to_string(), decl)))
-                .collect()
+                for (path, decl) in mod_decls {
+                    if !decl.is_empty() {
+                        if let Some(source) = docs.get(&path) {
+                            result.push((path.clone(), source.to_string(), decl));
+                        }
+                    }
+                }
+            }
+            result
         };
 
         for (mist_path, source, decl) in sources {
-            self.handle_transpile_and_notify(&mist_path, &source, &decl)
-                .await;
+            if let Some(transpiled) = self
+                .handle_transpile_and_notify(&mist_path, &source, &decl)
+                .await
+            {
+                if persist {
+                    Self::write_transpiled_to_disk(&transpiled);
+                }
+            }
         }
     }
 
     /// Create synthetic `package.mist` documents for subdirectories that contain
     /// .mist files but no real package.mist (implicit packages).
-    async fn ensure_implicit_packages(&self, src_root: &Path) {
+    async fn ensure_implicit_packages(&self) {
+        let ws = match &*self.workspace_folder.lock().await {
+            Some(p) => p.clone(),
+            None => return,
+        };
         let mut docs = self.documents.lock().await;
-        ensure_implicit_packages_impl(&mut *docs, src_root);
+        let crate_roots = collect_crate_roots(&docs, &ws);
+        for crate_root in &crate_roots {
+            let src_root = crate_root.join("src");
+            ensure_implicit_packages_impl(&mut *docs, &src_root);
+        }
+    }
+
+    /// Write a transpiled file's `.rs` content and `.map.json` mapping to disk.
+    /// The output directory is created if it doesn't exist.
+    fn write_transpiled_to_disk(transpiled: &TranspiledFile) {
+        if let Some(parent) = transpiled.rust_path.parent() {
+            if let Err(e) = std::fs::create_dir_all(parent) {
+                eprintln!("Failed to create output directory {:?}: {e}", parent);
+                return;
+            }
+        }
+        if let Err(e) = std::fs::write(&transpiled.rust_path, &transpiled.rust_content) {
+            eprintln!(
+                "Failed to write transpiled file {:?}: {e}",
+                transpiled.rust_path
+            );
+            return;
+        }
+        let map_path = transpiled.rust_path.with_extension("map.json");
+        if let Ok(map_json) = serde_json::to_string(&transpiled.mapping) {
+            if let Err(e) = std::fs::write(&map_path, &map_json) {
+                eprintln!("Failed to write mapping file {:?}: {e}", map_path);
+            }
+        }
     }
 
     async fn publish_diagnostics(&self, uri: Url, diagnostics: Vec<Diagnostic>) {
@@ -730,8 +782,6 @@ impl LanguageServer for Backend {
 
         tokio::spawn(async move {
             if let Some(root) = &*ws.lock().await {
-                let src_root = root.join("src");
-
                 // Hold the lock across both initialize + initialized so the
                 // editor's didOpen cannot race in-between and send notifications
                 // to rust-analyzer before it has received Initialized.
@@ -748,7 +798,21 @@ impl LanguageServer for Backend {
                 }
 
                 let mut files = Vec::new();
-                collect_mist_files(&src_root, &mut files);
+                collect_mist_files(&root.join("src"), &mut files);
+
+                // Discover subcrates by scanning for Mist.toml in immediate
+                // subdirectories of the workspace root.
+                let mut subcrate_roots = Vec::new();
+                if let Ok(entries) = std::fs::read_dir(root) {
+                    for entry in entries.flatten() {
+                        let entry_path = entry.path();
+                        if entry_path.is_dir() && entry_path.join("Mist.toml").is_file() {
+                            let sub_src = entry_path.join("src");
+                            collect_mist_files(&sub_src, &mut files);
+                            subcrate_roots.push(entry_path);
+                        }
+                    }
+                }
 
                 for file in &files {
                     if let Ok(text) = std::fs::read_to_string(file) {
@@ -761,15 +825,32 @@ impl LanguageServer for Backend {
 
                 eprintln!("Loaded {} mist files", files.len());
 
-                ensure_implicit_packages_impl(&mut *documents.lock().await, &src_root);
+                // Create implicit packages per crate root
+                {
+                    let mut docs = documents.lock().await;
+                    let all_crate_roots: Vec<PathBuf> = std::iter::once(root.clone())
+                        .chain(subcrate_roots.iter().cloned())
+                        .collect();
+                    for crate_root in &all_crate_roots {
+                        ensure_implicit_packages_impl(&mut *docs, &crate_root.join("src"));
+                    }
+                }
 
-                // Compute mod_decls before any transpile so the root file gets its
-                // child module declarations from the very first didOpen.
-                let package_mist = read_mist_package(root);
-                let src_root = root.join("src");
+                // Compute mod_decls per crate root before any transpile so each
+                // crate's root file gets its child module declarations.
+                let all_crate_roots: Vec<PathBuf> = std::iter::once(root.clone())
+                    .chain(subcrate_roots.iter().cloned())
+                    .collect();
                 let mod_decls = {
                     let docs = documents.lock().await;
-                    compute_mod_decls(&docs, &src_root, &package_mist)
+                    let mut merged = HashMap::new();
+                    for crate_root in &all_crate_roots {
+                        let cr_src = crate_root.join("src");
+                        let pkg = read_mist_package(crate_root);
+                        let decls = compute_mod_decls(&docs, &cr_src, &pkg);
+                        merged.extend(decls);
+                    }
+                    merged
                 };
 
                 for file in &files {
@@ -819,14 +900,22 @@ impl LanguageServer for Backend {
                     .cloned()
                     .collect();
                 for syn_path in &synthetic_paths {
-                    let decl = mod_decls.get(syn_path).map(String::as_str).unwrap_or("");
+                    // Find the crate root for this synthetic file
+                    let syn_crate_root = find_crate_root(syn_path).unwrap_or_else(|| root.clone());
+                    let pkg = read_mist_package(&syn_crate_root);
+                    let cr_src = syn_crate_root.join("src");
+                    let decl = {
+                        let docs = documents.lock().await;
+                        let crate_decls = compute_mod_decls(&docs, &cr_src, &pkg);
+                        crate_decls.get(syn_path).cloned().unwrap_or_default()
+                    };
                     let source = documents
                         .lock()
                         .await
                         .get(syn_path)
                         .map(|r| r.to_string())
                         .unwrap_or_default();
-                    if let Ok(transpiled) = transpile_mist(syn_path, &source, decl) {
+                    if let Ok(transpiled) = transpile_mist(syn_path, &source, &decl) {
                         if let Some(rust_uri) = clean_lsp_url(&transpiled.rust_path) {
                             let _ = ra
                                 .lock()
@@ -949,9 +1038,10 @@ impl LanguageServer for Backend {
             .await
             .insert(mist_path.clone(), Rope::from_str(&source));
 
-        self.handle_transpile_and_notify(&mist_path, &source, "")
+        let extra_decl = self.compute_mod_decl_for_file(&mist_path).await;
+        self.handle_transpile_and_notify(&mist_path, &source, &extra_decl)
             .await;
-        self.rebuild_module_tree().await;
+        self.rebuild_module_tree(false).await;
     }
 
     async fn did_change(&self, params: DidChangeTextDocumentParams) {
@@ -971,9 +1061,10 @@ impl LanguageServer for Backend {
                 .await
                 .insert(mist_path.clone(), Rope::from_str(&source));
 
-            self.handle_transpile_and_notify(&mist_path, &source, "")
+            let extra_decl = self.compute_mod_decl_for_file(&mist_path).await;
+            self.handle_transpile_and_notify(&mist_path, &source, &extra_decl)
                 .await;
-            self.rebuild_module_tree().await;
+            self.rebuild_module_tree(false).await;
         }
     }
 
@@ -986,17 +1077,36 @@ impl LanguageServer for Backend {
             }
         };
 
-        if let Some(text) = params.text {
+        let text = if let Some(text) = &params.text {
+            text.clone()
+        } else {
+            tokio::fs::read_to_string(&mist_path)
+                .await
+                .expect("Failed to read file")
+        };
+
         self.documents
             .lock()
             .await
             .insert(mist_path.clone(), Rope::from_str(&text));
 
-            self.handle_transpile_and_notify(&mist_path, &text, "")
+        let extra_decl = self.compute_mod_decl_for_file(&mist_path).await;
+        if let Some(transpiled) = self
+            .handle_transpile_and_notify(&mist_path, &text, &extra_decl)
+            .await
+        {
+            Self::write_transpiled_to_disk(&transpiled);
+            if let Some(rust_uri) = clean_lsp_url(&transpiled.rust_path) {
+                let _ = self
+                    .rust_analyzer
+                    .lock()
+                    .await
+                    .did_save(rust_uri, &transpiled.rust_content)
                     .await;
-            self.rebuild_module_tree().await;
             }
         }
+        self.rebuild_module_tree(true).await;
+    }
 
     async fn did_close(&self, params: DidCloseTextDocumentParams) {
         let uri = params.text_document.uri;
@@ -1010,13 +1120,10 @@ impl LanguageServer for Backend {
         self.documents.lock().await.remove(&mist_path);
 
         let rust_path = mist_to_rust_path(&mist_path);
-        self.mapping.lock().await.remove(&rust_path);
 
         if let Some(rust_uri) = clean_lsp_url(&rust_path) {
             let _ = self.rust_analyzer.lock().await.did_close(rust_uri).await;
         }
-
-        self.publish_diagnostics(uri, Vec::new()).await;
     }
 
     async fn completion(
@@ -1775,9 +1882,6 @@ async fn handle_ra_notifications(
                     };
 
                     if let Some(mist_uri) = mist_uri.or(Some(rust_uri.clone())) {
-                        let prev = previous_diagnostics.lock().await.get(&mist_uri).cloned();
-
-                        if prev.as_ref() != Some(&mapped_diagnostics) {
                         previous_diagnostics
                             .lock()
                             .await
@@ -1788,7 +1892,6 @@ async fn handle_ra_notifications(
                     }
                 }
             }
-            }
             _ => {}
         }
     }
@@ -1842,13 +1945,6 @@ fn read_mist_package(workspace_root: &Path) -> String {
         .unwrap_or_else(|| "main.mist".to_string())
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-pub struct MistConfig {
-    pub package: PathBuf,
-    pub packages: Vec<PathBuf>,
-    pub fmt: Option<MistFmtConfig>,
-}
-
 fn read_mist_fmt(workspace_root: &Path) -> Option<MistFmtConfig> {
     let toml_path = workspace_root.join("Mist.toml");
     let content = match std::fs::read_to_string(&toml_path) {
@@ -1860,9 +1956,31 @@ fn read_mist_fmt(workspace_root: &Path) -> Option<MistFmtConfig> {
         }
     };
 
-    toml::from_str::<MistConfig>(&content)
-        .ok()
-        .and_then(|v| v.fmt)
+    toml::from_str::<MistConfig>(&content).ok().map(|v| v.fmt)
+}
+
+fn find_crate_root(file_path: &Path) -> Option<PathBuf> {
+    let mut dir = file_path.parent()?;
+    loop {
+        if dir.join("Mist.toml").is_file() {
+            return Some(dir.to_path_buf());
+        }
+        dir = match dir.parent() {
+            Some(p) => p,
+            None => return None,
+        };
+    }
+}
+
+fn collect_crate_roots(docs: &HashMap<PathBuf, Rope>, workspace_root: &Path) -> HashSet<PathBuf> {
+    let mut roots = HashSet::new();
+    roots.insert(workspace_root.to_path_buf());
+    for path in docs.keys() {
+        if let Some(crate_root) = find_crate_root(path) {
+            roots.insert(crate_root);
+        }
+    }
+    roots
 }
 
 fn compute_mod_decls(
@@ -1889,20 +2007,30 @@ fn compute_mod_decls(
         let mut sorted = files.clone();
         sorted.sort();
         for file in &sorted {
-            let stem = match file.file_stem().and_then(|s| s.to_str()) {
-                Some(s) => s,
-                None => continue,
-            };
             // Skip the root package entry file (e.g. main.mist)
             if *file == package_path {
                 continue;
             }
             // Skip any subdirectory package.mist — it's the directory's own
             // entry file, not a sibling submodule.
-            if stem == "package" {
+            if file.file_name().and_then(|s| s.to_str()) == Some("package.mist") {
                 continue;
             }
-            mod_decl.push_str(&format!("pub mod {};\n", stem));
+            // Use the module declaration from the file if present,
+            // otherwise fall back to file stem.
+            let mod_name = documents
+                .get(file)
+                .and_then(|rope| {
+                    let source = rope.to_string();
+                    parse_module(&source).ok().flatten().map(|(_, name)| name.0)
+                })
+                .or_else(|| {
+                    file.file_stem()
+                        .and_then(|s| s.to_str().map(String::from))
+                });
+            if let Some(name) = mod_name {
+                mod_decl.push_str(&format!("pub mod {};\n", name));
+            }
         }
 
         if dir == src_root {

crates/analyzer/src/rust_analyzer.rs

@@ -374,6 +374,23 @@ impl RustAnalyzer {
         .await
     }
 
+    pub async fn did_save(
+        &mut self,
+        uri: Url,
+        text: &str,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        self.notify(
+            "textDocument/didSave",
+            json!({
+                "textDocument": {
+                    "uri": uri,
+                },
+                "text": text,
+            }),
+        )
+        .await
+    }
+
     pub async fn did_close(
         &mut self,
         uri: Url,

crates/analyzer/src/transpiler.rs

@@ -1,7 +1,6 @@
 use std::path::{Path, PathBuf};
 
 use mist_codegen::RustCodegen;
-use mist_codegen::fmt::MistCodegen;
 use mist_parser::rev_mapper::Mapping;
 use mist_parser::{MistFmtConfig, parse};
 
@@ -85,12 +84,13 @@ pub fn transpile_mist_no_sem(
     })
 }
 
-pub fn format_mist(source: &str, config: MistFmtConfig) -> Result<String, String> {
-    let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
+pub fn format_mist(source: &str, _config: MistFmtConfig) -> Result<String, String> {
+    // let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
 
-    let mut codegen = MistCodegen::new(config);
-    codegen.generate(parsed.mod_attributes);
-    let output = codegen.generate(parsed.items);
+    // let mut codegen = MistCodegen::new(config);
+    // codegen.generate(parsed.mod_attributes);
+    // let output = codegen.generate(parsed.items);
 
-    Ok(output)
+    // Ok(output)
+    Ok(source.to_string())
 }

crates/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-codegen"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 edition = "2024"
 description = "The Mist programming language Rust code generator"
 license = "Apache-2.0"

crates/codegen/src/class_decl.rs

@@ -362,7 +362,6 @@ impl ClassProcessedData {
             if *i > 0 {
                 cg.add(", ");
             }
-            ctx.expr_ensure_semicolon = false;
             param.name.gen_rust(ctx, cg);
         }
         cg.addln(");");
@@ -599,7 +598,6 @@ pub fn gen_method_point(method: &FunctionDecl, ctx: &mut Context, cg: &mut RustC
 
     for (_, param) in &params {
         cg.add(", ");
-        ctx.expr_ensure_semicolon = false;
         param.name.gen_rust(ctx, cg);
     }
 

crates/codegen/src/expr.rs

@@ -68,14 +68,6 @@ impl GenRust for Literal {
 
 impl GenRust for Expression {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        let ensure_semicolon = if ctx.expr_ensure_semicolon {
-            ctx.expr_ensure_semicolon = false;
-
-            true
-        } else {
-            false
-        };
-
         match self {
             Expression::Path(path) => cg.add(&path.get_rust_ctx(ctx)),
             Expression::Literal(literal) => literal.gen_rust(ctx, cg),
@@ -152,14 +144,6 @@ impl GenRust for Expression {
                 }
             }
         }
-
-        if ensure_semicolon {
-            ctx.expr_ensure_semicolon = true;
-
-            if !self.is_block() {
-                cg.add(";");
-            }
-        }
     }
 }
 

crates/codegen/src/fmt/expr.rs

@@ -1,171 +0,0 @@
-use mist_parser::ast::*;
-
-use crate::fmt::{Context, GenMist, GetMist, MistCodegen};
-
-impl GenMist for Expression {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        let ensure_semicolon = if ctx.expr_ensure_semicolon {
-            ctx.expr_ensure_semicolon = false;
-            true
-        } else {
-            false
-        };
-
-        match self {
-            Expression::Path(path) => cg.add(&path.get_mist()),
-            Expression::Literal(literal) => literal.gen_mist(ctx, cg),
-            Expression::Statement(stmt) => stmt.gen_mist(ctx, cg),
-            Expression::Array(values) => {
-                cg.add("[");
-                for (i, val) in values.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    val.gen_mist(ctx, cg);
-                }
-                cg.add("]");
-            }
-            Expression::ArrayRepeat(value, repeat) => {
-                cg.add("[");
-                value.gen_mist(ctx, cg);
-                cg.add("; ");
-                repeat.gen_mist(ctx, cg);
-                cg.add("]");
-            }
-            Expression::Fix {
-                initial,
-                prefixes,
-                postfixes,
-            } => {
-                for prefix in prefixes {
-                    prefix.gen_mist(ctx, cg);
-                }
-                initial.gen_mist(ctx, cg);
-                for postfix in postfixes {
-                    postfix.gen_mist(ctx, cg);
-                }
-            }
-            Expression::Binary { lhs, op, rhs } => {
-                lhs.gen_mist(ctx, cg);
-                cg.add(" ");
-                cg.add(op);
-                cg.add(" ");
-                rhs.gen_mist(ctx, cg);
-            }
-            Expression::Closure {
-                return_type,
-                params,
-                body,
-            } => {
-                cg.add("(");
-                for (i, arg) in params.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    arg.gen_mist(ctx, cg);
-                }
-                cg.add(") => ");
-
-                if let Some(ty) = return_type {
-                    cg.add(&ty.get_mist());
-                    cg.add(" ");
-                    cg.ensure_brackets_expr(ctx, body);
-                } else {
-                    body.gen_mist(ctx, cg);
-                }
-            }
-        }
-
-        if ensure_semicolon {
-            ctx.expr_ensure_semicolon = true;
-            if !self.is_block() {
-                cg.add(";");
-            }
-        }
-    }
-}
-
-impl GenMist for Prefix {
-    fn gen_mist(&self, _ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Self::Deref => cg.add("*"),
-            Self::Ref => cg.add("&"),
-            Self::RefMut => cg.add("&mut "),
-            Self::Not => cg.add("!"),
-            Self::Neg => cg.add("-"),
-        }
-    }
-}
-
-impl GenMist for Postfix {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Postfix::TupleFieldAccess(field, generics) => {
-                cg.add(&format!(
-                    ".{}{}",
-                    field,
-                    generics
-                        .iter()
-                        .map(|v| format!("::{}", v.get_mist()))
-                        .collect::<String>()
-                ));
-            }
-            Postfix::FieldAccess(field, generics) => {
-                cg.add(&format!(
-                    ".{}{}",
-                    field.get_mist(),
-                    generics
-                        .iter()
-                        .map(|v| format!("::{}", v.get_mist()))
-                        .collect::<String>()
-                ));
-            }
-            Postfix::Call(args) => {
-                cg.add("(");
-                for (i, arg) in args.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    arg.gen_mist(ctx, cg);
-                }
-                cg.add(")");
-            }
-            Postfix::MacroCall { inner, delimiter } => {
-                let (open, close) = match delimiter {
-                    MacroDelimiter::Paren => ("!(", ")"),
-                    MacroDelimiter::Bracket => ("![", "]"),
-                    MacroDelimiter::Brace => ("!{", "}"),
-                };
-                cg.add(open);
-                cg.add(inner);
-                cg.add(close);
-            }
-            Postfix::StructCall(fields) => {
-                cg.addln(" {");
-                cg.indent += 1;
-                for (name, expr) in fields {
-                    cg.add_indented(&name.get_mist());
-                    if let Some(expr) = expr {
-                        cg.add(": ");
-                        expr.gen_mist(ctx, cg);
-                    }
-                    cg.addln(",");
-                }
-                cg.indent -= 1;
-                cg.add_indented("}");
-            }
-            Postfix::Index(idx) => {
-                cg.add("[");
-                idx.gen_mist(ctx, cg);
-                cg.add("]");
-            }
-            Postfix::As(ty) => {
-                cg.add(" as ");
-                cg.add(&ty.get_mist());
-            }
-            Postfix::Try => cg.add("?"),
-            Postfix::Increment => cg.add("++"),
-            Postfix::Decrement => cg.add("--"),
-        }
-    }
-}

crates/codegen/src/fmt/mod.rs

@@ -1,450 +0,0 @@
-pub mod expr;
-pub mod statement;
-pub mod top_level;
-
-use mist_parser::{MistFmtConfig, ast::*};
-
-pub struct Context {
-    pub expr_ensure_semicolon: bool,
-}
-
-pub struct MistCodegen {
-    config: MistFmtConfig,
-    indent_amount: u8,
-    output: String,
-    indent: usize,
-}
-
-impl MistCodegen {
-    pub fn new(config: MistFmtConfig) -> Self {
-        Self {
-            config,
-            output: String::new(),
-            indent: 0,
-            indent_amount: 4,
-        }
-    }
-
-    fn indent_str(&self) -> String {
-        " ".repeat(self.indent_amount as usize).repeat(self.indent)
-    }
-
-    pub fn add(&mut self, s: &str) {
-        self.output.push_str(s);
-    }
-
-    pub fn addln(&mut self, s: &str) {
-        self.add(s);
-        self.add("\n");
-    }
-
-    pub fn add_indented(&mut self, s: &str) {
-        let line = format!("{}{}", self.indent_str(), s);
-        self.add(&line);
-    }
-
-    pub fn add_indentedln(&mut self, s: &str) {
-        let line = format!("{}{}\n", self.indent_str(), s);
-        self.add(&line);
-    }
-
-    pub fn start_indent(&mut self) {
-        if self.config.allman_bracket_style {
-            self.addln("");
-            self.add_indented("");
-        } else {
-            self.add(" ");
-        }
-    }
-
-    pub fn start_bracket(&mut self) {
-        if self.config.allman_bracket_style {
-            self.addln("");
-            self.add_indentedln("{");
-        } else {
-            self.addln(" {");
-        }
-
-        self.indent += 1;
-    }
-
-    pub fn into_output(self) -> String {
-        self.output
-    }
-
-    pub fn generate(&mut self, toplevels: Vec<TopLevel>) -> String {
-        let mut ctx = Context {
-            expr_ensure_semicolon: true,
-        };
-
-        for (i, tl) in toplevels.iter().enumerate() {
-            if i > 0 {
-                self.add("\n");
-            }
-            tl.gen_mist(&mut ctx, self);
-        }
-
-        self.output.clone()
-    }
-
-    pub fn ensure_brackets(&mut self, ctx: &mut Context, stmt: &Box<Statement>) {
-        match &**stmt {
-            Statement::Block(_) => stmt.gen_mist(ctx, self),
-            _ => {
-                self.add("{");
-                self.indent += 1;
-                stmt.gen_mist(ctx, self);
-                self.indent -= 1;
-                self.add_indented("}");
-            }
-        }
-    }
-
-    pub fn ensure_brackets_expr(&mut self, ctx: &mut Context, expr: &Expression) {
-        match expr {
-            Expression::Statement(stmt) => self.ensure_brackets(ctx, stmt),
-            _ => {
-                self.add("{");
-                self.indent += 1;
-                expr.gen_mist(ctx, self);
-                self.indent -= 1;
-                self.add_indented("}");
-            }
-        }
-    }
-}
-
-pub trait GenMist {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen);
-}
-
-pub trait GetMist {
-    fn get_mist(&self) -> String;
-}
-
-impl GetMist for Path {
-    fn get_mist(&self) -> String {
-        self.0
-            .iter()
-            .map(Identifier::get_mist)
-            .collect::<Vec<String>>()
-            .join("::")
-    }
-}
-
-impl GetMist for Identifier {
-    fn get_mist(&self) -> String {
-        self.0.clone()
-    }
-}
-
-impl GetMist for Visibility {
-    fn get_mist(&self) -> String {
-        match self {
-            Visibility::Public => "pub ".to_string(),
-            Visibility::PublicTarget(path) => format!("pub({}) ", path.get_mist()),
-            Visibility::Private => "".to_string(),
-        }
-    }
-}
-
-impl GetMist for TypeExpr {
-    fn get_mist(&self) -> String {
-        match self {
-            Self::Path(path, generics) => {
-                if let Some(generics) = generics {
-                    format!("{}{}", path.get_mist(), generics.get_mist())
-                } else {
-                    path.get_mist()
-                }
-            }
-            Self::Lifetime(name) => format!("'{}", name.get_mist()),
-            Self::Tuple(types) => format!(
-                "({})",
-                types
-                    .iter()
-                    .map(|t| t.get_mist())
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-            Self::StaticFn(types, return_type) => {
-                if let Some(return_type) = return_type {
-                    format!(
-                        "fn({}) -> {}",
-                        types
-                            .iter()
-                            .map(|t| t.get_mist())
-                            .collect::<Vec<_>>()
-                            .join(", "),
-                        return_type.get_mist()
-                    )
-                } else {
-                    format!(
-                        "fn({})",
-                        types
-                            .iter()
-                            .map(|t| t.get_mist())
-                            .collect::<Vec<_>>()
-                            .join(", "),
-                    )
-                }
-            }
-            Self::UnsafePtr { mutable, ty } => {
-                let mutable = if *mutable { "mut " } else { "const " };
-                format!("{} {mutable} unsafe&", ty.get_mist())
-            }
-            Self::Ref {
-                lifetime,
-                mutable,
-                ty,
-            } => {
-                let base = ty.get_mist();
-                if let Some(lifetime) = lifetime {
-                    format!(
-                        "{} {} '{}&",
-                        base,
-                        if *mutable { "mut" } else { "" },
-                        lifetime.get_mist()
-                    )
-                } else if *mutable {
-                    format!("{} mut&", base)
-                } else {
-                    format!("{}&", base)
-                }
-            }
-            Self::Dyn(ty) => {
-                format!("dyn {}", ty.get_mist())
-            }
-            Self::Void => "void".to_string(),
-            Self::Fn {
-                kind,
-                return_type,
-                params,
-            } => {
-                format!(
-                    "{} {}({})",
-                    return_type.get_mist(),
-                    kind.get_mist(),
-                    params
-                        .iter()
-                        .map(TypeExpr::get_mist)
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
-            }
-        }
-    }
-}
-
-impl GetMist for FnKind {
-    fn get_mist(&self) -> String {
-        match self {
-            Self::Fn => "fn",
-            Self::UnsafeFn => "unsafe fn",
-            Self::FnClosure => "Fn",
-            Self::FnMut => "FnMut",
-            Self::FnOnce => "FnOnce",
-        }
-        .to_string()
-    }
-}
-
-impl GetMist for ExprPath {
-    fn get_mist(&self) -> String {
-        self.0
-            .iter()
-            .map(ExprPathSegment::get_mist)
-            .collect::<Vec<_>>()
-            .join("::")
-    }
-}
-
-impl GetMist for ExprPathSegment {
-    fn get_mist(&self) -> String {
-        format!(
-            "{}{}",
-            self.ident.get_mist(),
-            self.generics
-                .as_ref()
-                .map(|v| format!("::{}", v.get_mist()))
-                .unwrap_or_default()
-        )
-    }
-}
-
-impl GetMist for Generics {
-    fn get_mist(&self) -> String {
-        if self.0.is_empty() {
-            String::new()
-        } else {
-            format!(
-                "<{}>",
-                self.0
-                    .iter()
-                    .map(Generic::get_mist)
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            )
-        }
-    }
-}
-
-impl GetMist for Generic {
-    fn get_mist(&self) -> String {
-        match self {
-            Self::Lifetime(name) => format!("'{}", name.get_mist()),
-            Self::Type(ty) => ty.get_mist(),
-        }
-    }
-}
-
-impl GetMist for GenericsDecl {
-    fn get_mist(&self) -> String {
-        if self.0.is_empty() {
-            String::new()
-        } else {
-            format!(
-                "<{}>",
-                self.0
-                    .iter()
-                    .map(|v| v.get_mist())
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            )
-        }
-    }
-}
-
-impl GetMist for GenericDecl {
-    fn get_mist(&self) -> String {
-        match self {
-            GenericDecl::Lifetime(name) => format!("'{}", name.get_mist()),
-            GenericDecl::Type(name, requirements) => {
-                name.get_mist()
-                    + &(if !requirements.is_empty() {
-                        format!(
-                            ": {}",
-                            requirements
-                                .iter()
-                                .map(TypeExpr::get_mist)
-                                .collect::<Vec<_>>()
-                                .join(" + ")
-                        )
-                    } else {
-                        String::new()
-                    })
-            }
-        }
-    }
-}
-
-impl<T: GetMist> GenMist for T {
-    fn gen_mist(&self, _: &mut Context, cg: &mut MistCodegen) {
-        cg.add(&self.get_mist());
-    }
-}
-
-impl<T: GenMist> GenMist for Spanned<T> {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        self.item.gen_mist(ctx, cg);
-    }
-}
-
-impl GenMist for Attribute {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Self::Path(path) => cg.add(&path.get_mist()),
-            Self::NameValue { path, value } => {
-                cg.add(&format!("{} = ", path.get_mist()));
-                value.gen_mist(ctx, cg);
-            }
-            Self::List { path, items } => {
-                cg.add(&path.get_mist());
-                cg.add("(");
-                for (i, item) in items.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    item.gen_mist(ctx, cg);
-                }
-                cg.add(")");
-            }
-        }
-    }
-}
-
-impl GenMist for Pattern {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Self::Etc => cg.add(".."),
-            Self::Literal(lit) => lit.gen_mist(ctx, cg),
-            Self::Path(mutable, path) => {
-                if *mutable {
-                    cg.add("mut ");
-                }
-                cg.add(&path.get_mist())
-            }
-            Self::Struct(path, inner) => {
-                cg.add(&path.get_mist());
-                cg.add(" {");
-                for (idx, i) in inner.iter().enumerate() {
-                    if idx > 0 {
-                        cg.add(", ");
-                    }
-                    if let Some((name, pat)) = i {
-                        cg.add(&name.get_mist());
-                        if let Some(pat) = pat {
-                            cg.add(": ");
-                            pat.gen_mist(ctx, cg);
-                        }
-                    } else {
-                        cg.add("..");
-                    }
-                }
-                cg.add("}");
-            }
-            Self::NamedTuple(path, inner) => {
-                cg.add(&path.get_mist());
-                cg.add("(");
-                for (i, pat) in inner.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    pat.gen_mist(ctx, cg);
-                }
-                cg.add(")");
-            }
-            Self::Tuple(inner) => {
-                cg.add("(");
-                for (i, pat) in inner.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    pat.gen_mist(ctx, cg);
-                }
-                cg.add(")");
-            }
-        }
-    }
-}
-
-impl GenMist for Literal {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Self::Int(n) => cg.add(&n.to_string()),
-            Self::Float(n) => cg.add(&format!("{n:?}")),
-            Self::Bool(b) => cg.add(&b.to_string()),
-            Self::String(s) => cg.add(&format!("\"{s}\"")),
-            Self::Tuple(values) => {
-                cg.add("(");
-                for (i, val) in values.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-                    val.gen_mist(ctx, cg);
-                }
-                cg.add(")");
-            }
-        }
-    }
-}

crates/codegen/src/fmt/statement.rs

@@ -1,157 +0,0 @@
-use mist_parser::ast::*;
-
-use crate::fmt::{Context, GenMist, GetMist, MistCodegen};
-
-impl GenMist for Block {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        cg.addln("{");
-        cg.indent += 1;
-
-        for stmt in &self.statements {
-            ctx.expr_ensure_semicolon = true;
-            cg.add_indented("");
-            stmt.gen_mist(ctx, cg);
-            cg.addln("");
-        }
-
-        if let Some(soft_return) = &self.soft_return {
-            ctx.expr_ensure_semicolon = false;
-            cg.add_indented("");
-            soft_return.gen_mist(ctx, cg);
-            cg.addln("");
-        }
-
-        cg.indent -= 1;
-        cg.add_indented("}");
-    }
-}
-
-impl GenMist for Statement {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Statement::UnsafeBlock(block) => {
-                cg.add("unsafe ");
-                block.gen_mist(ctx, cg);
-            }
-            Statement::Block(block) => block.gen_mist(ctx, cg),
-            Statement::VarDecl(VarDeclStmt { decl, init }) => {
-                if decl.type_.is_some() {
-                    cg.add(&decl.type_.as_ref().unwrap().get_mist());
-                    cg.add(" ");
-                    decl.name.gen_mist(ctx, cg);
-                } else {
-                    cg.add("let ");
-                    decl.name.gen_mist(ctx, cg);
-                }
-                if let Some(init) = init {
-                    cg.add(" = ");
-                    init.gen_mist(ctx, cg);
-                }
-            }
-            Statement::Match(expr, match_items) => {
-                cg.add("match ");
-                expr.gen_mist(ctx, cg);
-                cg.add(" {");
-                if !match_items.is_empty() {
-                    cg.addln("");
-                    cg.indent += 1;
-                    for match_item in match_items {
-                        let MatchItem(pat, body) = &match_item.item;
-                        cg.add_indented("");
-                        for (i, p) in pat.iter().enumerate() {
-                            if i > 0 {
-                                cg.add(" | ");
-                            }
-                            p.gen_mist(ctx, cg);
-                        }
-                        cg.add(" => ");
-                        if body.is_block() {
-                            body.gen_mist(ctx, cg);
-                            cg.addln("");
-                        } else {
-                            ctx.expr_ensure_semicolon = false;
-                            body.gen_mist(ctx, cg);
-                            cg.addln(",");
-                        }
-                    }
-                    cg.indent -= 1;
-                    cg.add_indented("}");
-                } else {
-                    cg.add("}");
-                }
-            }
-            Statement::If {
-                initial,
-                else_if,
-                else_branch,
-            } => {
-                cg.add("if ");
-                ctx.expr_ensure_semicolon = false;
-                initial.condition.gen_mist(ctx, cg);
-                cg.add(" ");
-                initial.body.gen_mist(ctx, cg);
-
-                for else_if_branch in else_if {
-                    cg.add(" else if ");
-                    ctx.expr_ensure_semicolon = false;
-                    else_if_branch.condition.gen_mist(ctx, cg);
-                    cg.add(" ");
-                    else_if_branch.body.gen_mist(ctx, cg);
-                }
-
-                if let Some(else_br) = else_branch {
-                    cg.add(" else ");
-                    else_br.gen_mist(ctx, cg);
-                }
-            }
-            Statement::While(StatementBranch { condition, body }) => {
-                cg.add("while ");
-                condition.gen_mist(ctx, cg);
-                cg.add(" ");
-                body.gen_mist(ctx, cg);
-            }
-            Statement::Loop(body) => {
-                cg.add("loop ");
-                body.gen_mist(ctx, cg);
-            }
-            Statement::CStyleFor {
-                init,
-                condition,
-                update,
-                body,
-            } => {
-                cg.add("for (");
-                ctx.expr_ensure_semicolon = true;
-                init.gen_mist(ctx, cg);
-                cg.add(" ");
-                ctx.expr_ensure_semicolon = false;
-                condition.gen_mist(ctx, cg);
-                cg.add(" ");
-                update.gen_mist(ctx, cg);
-                cg.add(") ");
-                body.gen_mist(ctx, cg);
-            }
-            Statement::For {
-                pattern,
-                iterator,
-                body,
-            } => {
-                cg.add("for ");
-                pattern.gen_mist(ctx, cg);
-                cg.add(" in ");
-                iterator.gen_mist(ctx, cg);
-                cg.add(" ");
-                body.gen_mist(ctx, cg);
-            }
-            Statement::Return(expr) => {
-                cg.add("return");
-                if let Some(expr) = expr {
-                    cg.add(" ");
-                    expr.gen_mist(ctx, cg);
-                }
-            }
-            Statement::Break => cg.add("break"),
-            Statement::Continue => cg.add("continue"),
-        }
-    }
-}

crates/codegen/src/fmt/top_level.rs

@@ -1,336 +0,0 @@
-use mist_parser::ast::*;
-
-use crate::fmt::{Context, GenMist, GetMist, MistCodegen};
-
-impl GenMist for ImplDecl {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        cg.add_indented("impl ");
-        let generics = self.generics.get_mist();
-        if !generics.is_empty() {
-            cg.add(&generics);
-            cg.add(" ");
-        }
-        if let Some(trait_) = &self.trait_ {
-            cg.add(&trait_.get_mist());
-            cg.add(" for ");
-        }
-
-        cg.add(&self.target.get_mist());
-
-        cg.start_bracket();
-
-        for method in &self.methods {
-            method.gen_mist(ctx, cg);
-        }
-
-        cg.indent -= 1;
-        cg.add_indentedln("}");
-    }
-}
-
-impl GenMist for FunctionDecl {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        cg.add_indented(&self.visibility.get_mist());
-
-        if self.return_type.is_none() {
-            cg.add("void ");
-        } else {
-            cg.add(&self.return_type.as_ref().unwrap().get_mist());
-            cg.add(" ");
-        }
-
-        cg.add(&self.name.get_mist());
-        cg.add(&self.generics.get_mist());
-        cg.add("(");
-
-        if let Some((is_ref, lifetime, is_mut)) = &self.self_param {
-            if *is_ref {
-                cg.add("&");
-            }
-            if let Some(lifetime) = lifetime {
-                cg.add(&format!("'{} ", lifetime.0));
-            }
-            if *is_mut {
-                cg.add("mut ");
-            }
-            cg.add("self");
-            if !self.params.0.is_empty() {
-                cg.add(", ");
-            }
-        }
-
-        for (i, param) in self.params.0.iter().enumerate() {
-            if i > 0 {
-                cg.add(", ");
-            }
-            param.gen_mist(ctx, cg);
-        }
-
-        cg.add(")");
-
-        if let Some(override_spec) = &self.is_override {
-            cg.add(" override");
-            if let Some(path) = &override_spec.0 {
-                cg.add("(");
-                cg.add(&path.get_mist());
-                cg.add(")");
-            }
-        }
-
-        if let Some(body) = &self.body {
-            cg.start_indent();
-            body.gen_mist(ctx, cg);
-            cg.addln("");
-        } else {
-            cg.addln(";");
-        }
-    }
-}
-
-impl GenMist for ParamList {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        for (i, param) in self.0.iter().enumerate() {
-            if i > 0 {
-                cg.add(", ");
-            }
-            param.gen_mist(ctx, cg);
-        }
-    }
-}
-
-impl GenMist for VarDecl {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        if let Some(type_) = &self.type_ {
-            cg.add(&type_.get_mist());
-            cg.add(" ");
-        }
-        self.name.gen_mist(ctx, cg);
-    }
-}
-
-impl GetMist for FieldDecl {
-    fn get_mist(&self) -> String {
-        format!(
-            "{}{} {}",
-            self.visibility.get_mist(),
-            self.type_.get_mist(),
-            self.name.get_mist(),
-        )
-    }
-}
-
-impl GetMist for EnumItem {
-    fn get_mist(&self) -> String {
-        match self {
-            Self::Named(id) => id.get_mist(),
-            Self::Struct(id, s) => format!(
-                "{} {{{}}}",
-                id.get_mist(),
-                s.iter()
-                    .map(FieldDecl::get_mist)
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-            Self::Tuple(id, t) => format!(
-                "{}({})",
-                id.get_mist(),
-                t.iter()
-                    .map(TypeExpr::get_mist)
-                    .collect::<Vec<_>>()
-                    .join(", ")
-            ),
-        }
-    }
-}
-
-impl GenMist for TopLevel {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        if let TopLevelKind::ModAttribute = self.0.item {
-            for attr in &self.1 {
-                cg.add("#![");
-                attr.gen_mist(ctx, cg);
-                cg.addln("]");
-            }
-        } else {
-            for attr in &self.1 {
-                cg.add("#[");
-                attr.gen_mist(ctx, cg);
-                cg.addln("]");
-            }
-        }
-
-        self.0.gen_mist(ctx, cg);
-    }
-}
-
-impl GenMist for TopLevelKind {
-    fn gen_mist(&self, ctx: &mut Context, cg: &mut MistCodegen) {
-        match self {
-            Self::ModAttribute => {}
-            Self::Import(vis, path) => {
-                cg.addln(&format!("{}use {};", vis.get_mist(), path.get_mist()))
-            }
-            Self::DeclareModule(vis, name) => {
-                cg.addln(&format!("{}module {};", vis.get_mist(), name.get_mist()))
-            }
-            Self::FunctionDecl(decl) => decl.gen_mist(ctx, cg),
-            Self::ImplDecl(impl_) => impl_.gen_mist(ctx, cg),
-            Self::StructDecl {
-                visibility,
-                name,
-                generics,
-                fields,
-            } => {
-                cg.add(&format!(
-                    "{}struct {}{}",
-                    visibility.get_mist(),
-                    name.get_mist(),
-                    generics.get_mist()
-                ));
-
-                if fields.is_empty() {
-                    cg.add(" {}");
-                } else {
-                    cg.start_bracket();
-
-                    for field in fields {
-                        cg.add_indentedln(&format!("{},", field.item.get_mist()));
-                    }
-
-                    cg.indent -= 1;
-                    cg.add_indented("}");
-                }
-
-                cg.addln("");
-            }
-            Self::EnumDecl {
-                visibility,
-                name,
-                generics,
-                fields,
-            } => {
-                cg.add(&format!(
-                    "{}enum {}{}",
-                    visibility.get_mist(),
-                    name.get_mist(),
-                    generics.get_mist()
-                ));
-
-                if fields.is_empty() {
-                    cg.add(" {}");
-                } else {
-                    cg.start_bracket();
-
-                    for field in fields {
-                        cg.add_indentedln(&format!("{},", field.item.get_mist()));
-                    }
-
-                    cg.indent -= 1;
-                    cg.add_indented("}");
-                }
-
-                cg.addln("");
-            }
-            Self::TraitDecl {
-                visibility,
-                name,
-                generics,
-                requirements,
-                items,
-            } => {
-                cg.add(&format!(
-                    "{}trait {}{}",
-                    visibility.get_mist(),
-                    name.get_mist(),
-                    generics.get_mist()
-                ));
-                if !requirements.is_empty() {
-                    cg.add(" : ");
-                    cg.add(
-                        &requirements
-                            .iter()
-                            .map(TypeExpr::get_mist)
-                            .collect::<Vec<_>>()
-                            .join(" + "),
-                    );
-                }
-                cg.start_bracket();
-                for item in items {
-                    item.gen_mist(ctx, cg);
-                }
-                cg.indent -= 1;
-                cg.add_indentedln("}");
-            }
-            Self::ClassDecl {
-                visibility,
-                name,
-                generics,
-                inherits,
-                fields,
-                constructor,
-                items,
-            } => {
-                cg.add(&format!(
-                    "{}class {}{}",
-                    visibility.get_mist(),
-                    name.get_mist(),
-                    generics.get_mist()
-                ));
-                if let Some(inherits) = inherits {
-                    cg.add(" : ");
-                    cg.add(&inherits.get_mist());
-                }
-
-                cg.start_bracket();
-
-                for field in fields {
-                    cg.add_indented(&field.item.decl.get_mist());
-                    if let Some(init) = &field.item.init {
-                        cg.add(" = ");
-                        init.gen_mist(ctx, cg);
-                    }
-                    cg.addln(";");
-                }
-
-                if let Some(constructor) = constructor {
-                    if fields.len() > 0 {
-                        cg.addln("");
-                    }
-
-                    cg.add_indented(&constructor.item.visibility.get_mist());
-                    cg.add("constructor");
-                    cg.add(&constructor.item.generics.get_mist());
-                    cg.add("(");
-                    for (i, param) in constructor.item.params.0.iter().enumerate() {
-                        if i > 0 {
-                            cg.add(", ");
-                        }
-                        param.gen_mist(ctx, cg);
-                    }
-                    cg.add(") ");
-                    cg.start_indent();
-                    constructor.item.body.gen_mist(ctx, cg);
-                    cg.addln("");
-
-                    if items.len() > 0 {
-                        cg.addln("");
-                    }
-                }
-
-                for (i, item) in items.iter().enumerate() {
-                    if i > 0 {
-                        cg.addln("");
-                    }
-
-                    match item {
-                        ClassItem::Method(method) => method.gen_mist(ctx, cg),
-                        ClassItem::ImplDecl(impl_) => impl_.gen_mist(ctx, cg),
-                    }
-                }
-
-                cg.indent -= 1;
-                cg.add_indentedln("}");
-            }
-        }
-    }
-}

crates/codegen/src/lib.rs

@@ -1,6 +1,5 @@
 pub mod class_decl;
 pub mod expr;
-pub mod fmt;
 pub mod statement;
 pub mod top_level;
 
@@ -12,7 +11,6 @@ use mist_parser::{
 };
 
 pub struct Context {
-    pub expr_ensure_semicolon: bool,
     pub expr_super: Option<ExprPath>,
 }
 
@@ -81,7 +79,6 @@ impl RustCodegen {
 
     pub fn generate(&mut self, toplevels: Vec<TopLevel>) -> String {
         let mut ctx = Context {
-            expr_ensure_semicolon: true,
             expr_super: None,
         };
 

crates/codegen/src/statement.rs

@@ -10,14 +10,15 @@ impl GenRust for Block {
         cg.indent += 1;
 
         for stmt in &self.statements {
-            ctx.expr_ensure_semicolon = true;
             cg.add_indented("");
             stmt.gen_rust(ctx, cg);
+            if stmt.item.is_semicolon_required() {
+                cg.add(";");
+            }
             cg.addln("");
         }
 
         if let Some(soft_return) = &self.soft_return {
-            ctx.expr_ensure_semicolon = false;
             cg.add_indented("");
             soft_return.gen_rust(ctx, cg);
             cg.addln("");
@@ -31,13 +32,14 @@ impl GenRust for Block {
 impl GenRust for Statement {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
+            Statement::TopLevel(tl) => tl.gen_rust(ctx, cg),
+            Statement::Block(block) => block.gen_rust(ctx, cg),
+
             Statement::UnsafeBlock(block) => {
                 cg.add("unsafe ");
                 block.gen_rust(ctx, cg);
             }
 
-            Statement::Block(block) => block.gen_rust(ctx, cg),
-
             Statement::VarDecl(VarDeclStmt { decl, init }) => {
                 cg.add("let ");
                 decl.gen_rust(ctx, cg);
@@ -85,14 +87,12 @@ impl GenRust for Statement {
                 else_branch,
             } => {
                 cg.add("if ");
-                ctx.expr_ensure_semicolon = false;
                 initial.condition.gen_rust(ctx, cg);
                 cg.add(" ");
                 initial.body.gen_rust(ctx, cg);
 
                 for else_if_branch in else_if {
                     cg.add(" else if ");
-                    ctx.expr_ensure_semicolon = false;
                     else_if_branch.condition.gen_rust(ctx, cg);
                     cg.add(" ");
                     else_if_branch.body.gen_rust(ctx, cg);
@@ -125,17 +125,18 @@ impl GenRust for Statement {
                 cg.addln("{");
                 cg.indent += 1;
 
-                ctx.expr_ensure_semicolon = true;
-
                 cg.add_indented("");
 
                 init.gen_rust(ctx, cg);
 
+                if init.is_semicolon_required() {
+                    cg.add(";");
+                }
+
                 cg.addln("");
 
                 cg.add_indented("while ");
 
-                ctx.expr_ensure_semicolon = false;
                 condition.gen_rust(ctx, cg);
 
                 cg.add(" ");
@@ -143,12 +144,14 @@ impl GenRust for Statement {
                 cg.add("{");
                 cg.indent += 1;
 
-                ctx.expr_ensure_semicolon = true;
-
                 body.gen_rust(ctx, cg);
 
                 update.gen_rust(ctx, cg);
 
+                if update.is_semicolon_required() {
+                    cg.add(";");
+                }
+
                 cg.addln("");
 
                 cg.indent -= 1;

crates/codegen/src/top_level.rs

@@ -191,6 +191,38 @@ impl GenRust for TopLevelKind {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
             Self::ModAttribute => {}
+            Self::TypeAlias { name, generics, ty } => {
+                cg.add("type ");
+                name.gen_rust(ctx, cg);
+                if let Some(g) = generics {
+                    g.gen_rust(ctx, cg);
+                }
+                cg.add(" = ");
+                ty.gen_rust(ctx, cg);
+                cg.addln(";");
+            }
+            Self::ConstDecl(decl) => {
+                cg.add("const ");
+                decl.decl.gen_rust(ctx, cg);
+
+                if let Some(init) = &decl.init {
+                    cg.add(" = ");
+                    init.gen_rust(ctx, cg);
+                }
+
+                cg.addln(";");
+            }
+            Self::StaticDecl(decl) => {
+                cg.add("static ");
+                decl.decl.gen_rust(ctx, cg);
+
+                if let Some(init) = &decl.init {
+                    cg.add(" = ");
+                    init.gen_rust(ctx, cg);
+                }
+
+                cg.addln(";");
+            }
             Self::Import(vis, path) => {
                 cg.addln(&format!("{}use {};", vis.get_rust(), path.get_rust()))
             }

crates/mist-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-api"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 edition = "2024"
 description = "The Mist programming language module system"
 license = "Apache-2.0"

crates/mist-api/src/builder.mist

@@ -1,16 +1,24 @@
 pub module builder;
 
 use std::collections::HashMap;
+
 use std::fs;
+
 use std::path::PathBuf;
+
 use std::process::Command;
+
 use std::process::Stdio;
+
 use cargo_metadata::CompilerMessage;
+
 use cargo_metadata::Message;
+
 use mist_parser::rev_mapper;
 
 #[derive(Debug, Clone)]
-pub struct MistDiagnosticMessage {
+pub struct MistDiagnosticMessage
+{
     pub String message,
     pub PathBuf file_path,
     pub String file_name,
@@ -19,62 +27,42 @@ pub struct MistDiagnosticMessage {
 }
 
 #[derive(Debug, Clone)]
-pub enum MistDiagnostic {
+pub enum MistDiagnostic
+{
     Error(MistDiagnosticMessage),
     Warning(MistDiagnosticMessage),
     Rust(CompilerMessage),
 }
 
-pub bool build(Vec<String> mut args, PathBuf root) {
+pub bool build(Vec<String> mut args, PathBuf root)
+{
     args.remove(0);
     args.insert(1, "--message-format=json".to_string());
-
-    let mut command = Command::new("cargo")
-        .args(args)
-        .stdout(Stdio::piped())
-        .stderr(Stdio::inherit())
-        .stdin(Stdio::inherit())
-        .spawn()
-        .expect("Failed to run cargo");
-
+    let mut command = Command::new("cargo").args(args).stdout(Stdio::piped()).stderr(Stdio::inherit()).stdin(Stdio::inherit()).spawn().expect("Failed to run cargo");
     let mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader"));
-
     let mut diagnostics = Vec::new();
-
     let mut mapping = HashMap::new();
-
     for message in cargo_metadata::Message::parse_stream(&mut reader) {
         match message {
             Ok(Message::CompilerMessage(msg)) => {
                 for span in &msg.message.spans {
                     if span.is_primary {
                         let rust_path = root.join(&span.file_name);
-
                         let mapping_path = rust_path.with_extension("map.json");
-
                         if !fs::exists(&mapping_path).expect("Unable to check if map file exists") {
                             diagnostics.push(MistDiagnostic::Rust(msg));
                             break;
                         }
-
                         let map = mapping.entry(mapping_path.clone()).or_insert_with(() => {
                             let map_str = fs::read_to_string(mapping_path).expect("Failed to read map file");
-
                             serde_json::from_str<rev_mapper::Mapping>(&map_str).expect("Failed to parse map file")
                         });
-
                         let mist_file = map.mist_path.strip_prefix(&root);
-
-                        let (_, rev_mapper::MistMap(line, column)) =
-                            map.find(&rev_mapper::RustMap(span.line_end, span.column_start))
-                                .expect("Unable to find mapping");
-
+                        let (_, rev_mapper::MistMap(line, column)) = map.find(&rev_mapper::RustMap(span.line_end, span.column_start)).unwrap_or_default();
                         let mist_msg = MistDiagnosticMessage {
-                            message: format!(
-                                "{}: {}",
+                            message: format!("{}: {}",
                                 msg.message.message,
-                                span.label.clone().unwrap_or_default()
-                            ),
+                                span.label.clone().unwrap_or_default()),
                             file_name: if let Ok(mist_file) = mist_file {
                                 mist_file.to_string_lossy().to_string()
                             } else {
@@ -82,97 +70,70 @@ pub bool build(Vec<String> mut args, PathBuf root) {
                             },
                             file_path: map.mist_path.clone(),
                             line: line,
-                            column: column
+                            column: column,
                         };
-
                         match msg.message.level {
                             cargo_metadata::diagnostic::DiagnosticLevel::Error => {
                                 diagnostics.push(MistDiagnostic::Error(mist_msg))
                             }
-
                             cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
                                 diagnostics.push(MistDiagnostic::Warning(mist_msg))
                             }
-
-                            _ => {}
+                            _ => {
+                            }
                         }
                     }
                 }
             }
-
             Ok(Message::BuildFinished(finish)) => {
                 print_diagnostics(&diagnostics);
-
                 let mut raw_reader = reader.into_inner();
                 let mut stdout = std::io::stdout();
-
-                std::io::copy(&mut raw_reader, &mut stdout)
-                    .map_err((v) => v.to_string())
-                    .expect("(Mist) Failed to copy IO");
-
+                std::io::copy(&mut raw_reader, &mut stdout).map_err((v) => v.to_string()).expect("(Mist) Failed to copy IO");
                 command.wait().unwrap();
-
                 return finish.success;
             }
-
-            Ok(Message::TextLine(text)) => println!("{text}");
-            _ => {}
+            Ok(Message::TextLine(text)) => println!("{text}"),
+            _ => {
+            }
         }
     }
-
     false
 }
 
-pub void print_diagnostics(Vec<MistDiagnostic>& diagnostics) {
+pub void print_diagnostics(Vec<MistDiagnostic>& diagnostics)
+{
     let mut files = HashMap::new();
-
     for diag in diagnostics {
         match diag {
             MistDiagnostic::Error(msg) => {
                 let line = get_line(&mut files, &msg);
-
-                println!(
-                    "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}",
+                println!("\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}",
                     msg.file_name,
                     msg.line,
                     msg.column,
                     msg.message,
-                    line.unwrap_or_default(),
-                )
+                    line.unwrap_or_default(),)
             }
-
             MistDiagnostic::Warning(msg) => {
                 let line = get_line(&mut files, &msg);
-
-                println!(
-                    "\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}",
+                println!("\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}",
                     msg.file_name,
                     msg.line,
                     msg.column,
                     msg.message,
-                    line.unwrap_or_default(),
-                )
+                    line.unwrap_or_default(),)
             }
-
-            MistDiagnostic::Rust(rs) => println!("{rs}");
+            MistDiagnostic::Rust(rs) => println!("{rs}"),
         }
     }
 }
 
-pub Option<String> get_line(
-    HashMap<PathBuf, Vec<String>> mut& files,
-    MistDiagnosticMessage& msg,
-) {
+pub Option<String> get_line(HashMap<PathBuf, Vec<String>> mut& files, MistDiagnosticMessage& msg)
+{
     let src_path = msg.file_path.clone();
-
     let lines = files.entry(src_path.clone()).or_insert_with(() => {
-        fs::read_to_string(src_path)
-            .expect("Unable to read mist file")
-            .lines()
-            .into_iter()
-            .map(String::from)
-            .collect()
+        fs::read_to_string(src_path).expect("Unable to read mist file").lines().into_iter().map(String::from).collect()
     });
-
     lines.get(msg.line - 1).map((v) => v.trim().to_string())
 }

crates/mist-api/src/modules.mist

@@ -1,75 +1,72 @@
 pub module modules;
 
 use std::path::Path;
+
 use std::path::PathBuf;
+
 use std::fs;
+
 use std::process;
 
 use crate::transpiler::MistConfig;
 
 #[derive(Debug)]
-pub class Module {
+pub class Module
+{
     pub String name;
     pub PathBuf path;
     pub Vec<Module> children;
 
-    pub constructor(PathBuf mist_path, MistConfig& config) {
+    pub constructor(PathBuf mist_path, MistConfig& config) 
+    {
         self.children = Vec::new();
-        self.name = mist_path.file_stem()
-            .and_then((s) => s.to_str())
-            .expect("Failed to get module name")
-            .to_string();
+        self.name = mist_path.file_stem().and_then((s) => s.to_str()).expect("Failed to get module name").to_string();
         self.path = mist_path;
-
         if self.path.is_dir() {
             let dir = self.path.clone();
-
             let pkg_gate = self.path.join("package.mist");
             if pkg_gate.exists() {
                 self.path = pkg_gate;
             }
-
             self.scan_directory(&dir, config);
         } else if config.should_ignore(&self.path) {
             let dir = self.path.parent().expect("Failed to get parent directory to scan").to_path_buf();
-
             self.scan_directory(&dir, config);
         }
     }
 
-    void scan_directory(&mut self, Path& search_dir, MistConfig& config) {
+    void scan_directory(&mut self, Path& search_dir, MistConfig& config)
+    {
         let entries = match fs::read_dir(search_dir) {
-            Ok(entries) => entries;
+            Ok(entries) => entries,
             Err(e) => {
                 eprintln!("error: failed to read directory {}\n  {}", search_dir.display(), e);
                 process::exit(1);
             }
         };
-
         for entry in entries {
             let entry = match entry {
-                Ok(entry) => entry;
+                Ok(entry) => entry,
                 Err(e) => {
                     eprintln!("error: failed to read directory entry\n  {}", e);
                     process::exit(1);
                 }
             };
-
             let child_path = entry.path();
-
             if child_path == self.path || child_path == config.package {
                 continue;
             }
-
             self.children.push(Module::new(child_path, config));
         }
     }
 
-    pub bool is_package(&self) {
+    pub bool is_package(&self)
+    {
         self.path.file_name().map((v) => v.to_str()).unwrap_or_default() == Some("package.mist")
     }
 
-    pub PathBuf output_dir(&self, PathBuf& parent_dir) {
+    pub PathBuf output_dir(&self, PathBuf& parent_dir)
+    {
         if self.path.is_dir() || self.is_package() {
             parent_dir.join(&self.name)
         } else {
@@ -77,19 +74,15 @@ pub class Module {
         }
     }
 
-    pub PathBuf output_path(&self,
-            PathBuf& parent_dir,
-            Option<(
-                mist_parser::ast::Visibility, 
-                mist_parser::ast::Identifier
-            )>& curr_mod_decl
-        ) {
-        let name = if let Some((_, name)) = curr_mod_decl {
+    pub PathBuf output_path(&self, PathBuf& parent_dir, Option<(mist_parser::ast::Visibility, mist_parser::ast::Identifier)>& curr_mod_decl)
+    {
+        let name = if self.path.is_dir() || self.is_package() {
+            &self.name
+        } else if let Some((_, name)) = curr_mod_decl {
             &name.0
         } else {
             &self.name
         };
-
         if self.path.is_dir() || self.is_package() {
             parent_dir.join(name).join("mod.rs")
         } else {

crates/mist-api/src/transpiler.mist

@@ -1,170 +1,193 @@
 pub module transpiler;
 
 use std::fs;
+
 use std::path::Path;
+
 use std::path::PathBuf;
+
 use std::process;
+
 use std::time;
-use std::env;
 
 use mist_parser::error;
+
 use crate::modules;
+
 use mist_codegen::GetRust;
 
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
 #[serde(default)]
-pub struct MistConfig {
+pub struct MistConfig
+{
     pub PathBuf package,
     pub Vec<PathBuf> packages,
-    pub String main_mods
+    pub Vec<PathBuf> include,
+    pub mist_parser::MistFmtConfig fmt,
 }
 
-impl MistConfig {
-    pub bool should_ignore(&self, Path& path) {
+impl MistConfig
+{
+    pub bool should_ignore(&self, Path& path)
+    {
         if path == self.package {
             return true;
         }
-
         for pkg in &self.packages {
             if path.ends_with(pkg) {
                 return true;
             }
         }
-
         false
     }
 }
-impl Default for MistConfig {
- Self default() {
+
+impl Default for MistConfig
+{
+    Self default()
+    {
         Self {
             package: PathBuf::from("main.mist"),
             packages: Vec::new(),
-            main_mods: String::new(),
+            include: Vec::new(),
+            fmt: mist_parser::MistFmtConfig {
+                allman_bracket_style: true,
+            },
         }
     }
 }
 
-pub PathBuf transpile() {
+pub void transpile(Path& root)
+{
+    println!("\x1b[32m\nTranspiling\x1b[0m \x1b[94m{:?}\x1b[0m", root.file_name().unwrap_or_default());
     let start = time::Instant::now();
-
-    let root = env::current_dir().expect("Unable to find project root");
-
     let toml_path = root.join("Mist.toml");
     let src = root.join("src");
     let out = root.join(".mist/src");
-
-    let toml_content = fs::read_to_string(&toml_path)
-        .unwrap_or_else((_) => panic!("Could not read file at {:?}", toml_path));
-
-    MistConfig mut config = toml::from_str(&toml_content)
-        .unwrap_or_else((_) => panic!("Failed to parse Mist.toml from {:?}", toml_path));
-    
+    let toml_content = fs::read_to_string(&toml_path).unwrap_or_else((_) => panic!("Could not read file at {:?}", toml_path));
+    MistConfig mut config = toml::from_str(&toml_content).unwrap_or_else((_) => panic!("Failed to parse Mist.toml from {:?}", toml_path));
     for pkg in &mut config.packages {
         *pkg = src.join(&*pkg);
     }
-
     config.package = src.join(&*config.package);
-
-    let master = modules::Module::new(
-        config.package.clone(),
-        &config
-    );
-
-    master.transpile(&out, &mut config);
-
+    let master = modules::Module::new(config.package.clone(), &config);
+    master.transpile(&out, &mut config, &mut String::new());
     let elapsed = start.elapsed();
-
-    println!(
-        "\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m",
-        elapsed
-    );
-
-    root
-}
-
-impl modules::Module {
-    (bool, String) transpile(&self, PathBuf& parent_dir, MistConfig mut& config) {
-        if !self.path.is_dir() && self.path.extension().and_then((v) => v.to_str()) != Some("mist") {
-            let file_name = self.path.file_name()
-                .and_then((s) => s.to_str())
-                .expect("Failed to get file name");
-
-            fs::copy(&self.path, parent_dir.join(&file_name)).expect("Failed to copy SideFile");
-
-            return (true, String::new());
-        }
-
-        let dir = self.output_dir(parent_dir);
-
-        let _ = fs::create_dir_all(&dir);
-
-        let mut output = String::new();
-
-        let mut child_changed = false;
-
-        for child in &self.children {
-            if !config.should_ignore(&child.path) {
-                let out = child.transpile(&dir, config);
-                if out.0 {
-                    child_changed = true;
-                }
-
-                output.push_str(&out.1);
-            }
-        }
-
-        if self.path == config.package {
-            config.main_mods = output.clone();
-        } else if config.should_ignore(&self.path) {
-            output.push_str(&config.main_mods)
-        }
-
-        self.write_transpile(output, parent_dir, child_changed)
-    }
-
-    (bool, String) write_transpile(&self, String output, PathBuf& parent_dir, bool child_changed) {
-        if self.path.is_dir() {
-            let output_file = self.output_path(parent_dir, &None);
-
-            if output.len() == 0 {
-                return (true, String::new());
-            }
-
-            let res = fs::write(&output_file, output);
-
-            if res.is_err() {
-                eprintln!(
-                    "error: failed to write output {}\n  {}",
-                    output_file.display(),
-                    res.unwrap_err(),
-                );
-
-                process::exit(1);
-            }
-
-            (false, format!("pub mod {};\n", self.name))
-        } else {
-            let source = match fs::read_to_string(&self.path) {
-                Ok(s) => s;
+    println!("\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m", elapsed);
+    for incl in &config.include {
+        if ends_with_star(&incl) {
+            let sub_crates = incl.parent().expect("Failed to get parent");
+            let entries = match fs::read_dir(sub_crates) {
+                Ok(entries) => entries,
                 Err(e) => {
-                    eprintln!("error: failed to read file {}\n  {}", self.path.display(), e);
-
+                    eprintln!("error: failed to read directory {}\n  {}", sub_crates.display(), e);
                     process::exit(1);
                 }
             };
+            for sub_crate in entries {
+                if let Ok(sub_crate) = sub_crate {
+                    let sub_crate = sub_crate.path();
+                    if fs::exists(sub_crate.join("Mist.toml")).unwrap_or_default() {
+                        transpile(&sub_crate);
+                    }
+                }
+            }
+        } else {
+            transpile(incl);
+        }
+    }
+}
 
+bool ends_with_star(Path& path)
+{
+    path.file_name().and_then((name) => name.to_str()).is_some_and((name) => name.ends_with("*"))
+}
+
+impl modules::Module
+{
+    (bool, String) transpile(&self, PathBuf& parent_dir, MistConfig mut& config, String mut& main_mods)
+    {
+        if !self.path.is_dir() && self.path.extension().and_then((v) => v.to_str()) != Some("mist") {
+            let file_name = self.path.file_name().and_then((s) => s.to_str()).expect("Failed to get file name");
+            fs::copy(&self.path, parent_dir.join(&file_name)).expect("Failed to copy SideFile");
+            return (true, String::new());
+        }
+        let dir = self.output_dir(parent_dir);
+        let _ = fs::create_dir_all(&dir);
+        let mut output = String::new();
+        let mut child_changed = false;
+        for child in &self.children {
+            if !config.should_ignore(&child.path) {
+                let out = child.transpile(&dir, config, main_mods);
+                if out.0 {
+                    child_changed = true;
+                }
+                output.push_str(&out.1);
+            }
+        }
+        if self.path == config.package {
+            *main_mods = output.clone();
+        } else if config.should_ignore(&self.path) {
+            output.push_str(main_mods)
+        }
+        self.write_transpile(output, parent_dir, child_changed)
+    }
+    (bool, String) write_transpile(&self, String output, PathBuf& parent_dir, bool child_changed)
+    {
+        if self.path.is_dir() || self.is_package() {
+            let output_file = self.output_path(parent_dir, &None);
+            let final_output = if self.is_package() {
+                let source = match fs::read_to_string(&self.path) {
+                    Ok(s) => s,
+                    Err(e) => {
+                        eprintln!("error: failed to read file {}\n  {}", self.path.display(), e);
+                        process::exit(1);
+                    }
+                };
+                let curr_mod_decl = mist_parser::parse_module(&source).expect("Failed parsing module");
+                let (result_path, gc, rust_code) = match transpile_code(&self.path, &source, output_file.clone(), &output, &curr_mod_decl) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        decode_err(&e, &self.path);
+                        process::exit(1);
+                    }
+                };
+                let map_path = result_path.with_extension("map.json");
+                if let Some(parent) = map_path.parent() {
+                    let _ = fs::create_dir_all(parent);
+                }
+                fs::write(&map_path, serde_json::to_string(&gc.mapping).unwrap()).expect("Failed to write map file");
+                rust_code
+            } else {
+                if output.len() == 0 {
+                    return (true, String::new());
+                }
+                output
+            };
+            let res = fs::write(&output_file, final_output);
+            if res.is_err() {
+                eprintln!("error: failed to write output {}\n  {}",
+                    output_file.display(),
+                    res.unwrap_err(),);
+                process::exit(1);
+            }
+            (false, format!("pub mod {};\n", self.name))
+        } else {
+            let source = match fs::read_to_string(&self.path) {
+                Ok(s) => s,
+                Err(e) => {
+                    eprintln!("error: failed to read file {}\n  {}", self.path.display(), e);
+                    process::exit(1);
+                }
+            };
             let curr_mod_decl = mist_parser::parse_module(&source).expect("Failed parsing module");
-
             let output_file = self.output_path(parent_dir, &curr_mod_decl);
-
             let should_change = is_source_newer(&self.path, &output_file).expect("Failed to cache");
-
             if should_change || child_changed {
                 transpile_file(&self.path, &source, output_file, &output, &curr_mod_decl);
             }
-
             (should_change, if let Some((vis, name)) = &curr_mod_decl {
                 format!("{}mod {};\n", vis.get_rust(), name.get_rust())
             } else {
@@ -174,141 +197,104 @@ impl modules::Module {
     }
 }
 
-std::io::Result<bool> is_source_newer(Path& source, Path& output) {
+std::io::Result<bool> is_source_newer(Path& source, Path& output)
+{
     if !output.exists() {
         return Ok(true);
     }
-
     let source_time = fs::metadata(source)?.modified()?;
     let output_time = fs::metadata(output)?.modified()?;
-
     Ok(source_time > output_time)
 }
 
-pub enum TranspileError<'a> {
+pub enum TranspileError<'a>
+{
     Parse(error::ParseError<'a>),
-    Semantic(Vec<mist_parser::semantics::SemanticError>)
+    Semantic(Vec<mist_parser::semantics::SemanticError>),
 }
 
-pub Result<(PathBuf, mist_codegen::RustCodegen, String), TranspileError<'a>>
-    transpile_code<'a>(
-            PathBuf& path,
-            str 'a& source,
-            PathBuf mut output_file,
-            str& mod_decl,
-            Option<(mist_parser::ast::Visibility, mist_parser::ast::Identifier)>& curr_mod_decl
-    ) {
-
+pub Result<(PathBuf, mist_codegen::RustCodegen, String), TranspileError<'a>> transpile_code<'a>(PathBuf& path, str  'a& source, PathBuf mut output_file, str& mod_decl, Option<(mist_parser::ast::Visibility, mist_parser::ast::Identifier)>& curr_mod_decl)
+{
     if let Some((_, name)) = &curr_mod_decl {
         if output_file.file_name().map((v) => v.to_str()).unwrap_or_default() != Some("mod.rs") {
             if let Some(ext) = output_file.extension().map((e) => e.to_owned()) {
                 let mut new_name = std::ffi::OsString::from(&name.0);
-
                 new_name.push(".");
                 new_name.push(ext);
-
                 output_file.set_file_name(new_name);
             } else {
                 output_file.set_file_name(&name.0);
             }
         }
     }
-
     let mut gc = mist_codegen::RustCodegen::new(path.clone());
-
     let parsed = mist_parser::parse(source).map_err(TranspileError::Parse)?;
-
     for i in &parsed.items {
         let _ = mist_parser::semantics::check_class_semantics(i).map_err(TranspileError::Semantic)?;
     }
-
     gc.generate(parsed.mod_attributes);
-
     gc.add(mod_decl);
-
     let output = gc.generate(parsed.items);
-
     Ok((output_file, gc, output))
 }
 
-pub void transpile_file(
-        PathBuf& path,
-        str& source,
-        PathBuf output_file,
-        str& mod_decl,
-        Option<(mist_parser::ast::Visibility, mist_parser::ast::Identifier)>& curr_mod_decl
-    ) {
-
+pub void transpile_file(PathBuf& path, str& source, PathBuf output_file, str& mod_decl, Option<(mist_parser::ast::Visibility, mist_parser::ast::Identifier)>& curr_mod_decl)
+{
     let (output_file, gc, output) = match transpile_code(path, source, output_file, mod_decl, curr_mod_decl) {
-        Ok(output) => output;
+        Ok(output) => output,
         Err(e) => {
             decode_err(&e, path);
             process::exit(1);
         }
     };
-
+    if let Some(parent) = output_file.parent() {
+        let _ = fs::create_dir_all(parent);
+    }
     let res = fs::write(&output_file, output);
-
     let output_file_map = output_file.with_extension("map.json");
-
     let res_map = fs::write(&output_file_map, serde_json::to_string(&gc.mapping).unwrap());
-
     if res_map.is_err() {
-        eprintln!(
-            "error: failed to write mapping output {}\n  {}",
+        eprintln!("error: failed to write mapping output {}\n  {}",
             output_file_map.display(),
-            res.as_ref().unwrap_err(),
-        );
+            res_map.as_ref().unwrap_err(),);
     }
-
     if res.is_err() {
-        eprintln!(
-            "error: failed to write output {}\n  {}",
+        eprintln!("error: failed to write output {}\n  {}",
             output_file.display(),
-            res.as_ref().unwrap_err(),
-        );
+            res.as_ref().unwrap_err(),);
     }
-
     if res_map.is_err() || res.is_err() {
         process::exit(1);
     }
 }
 
-pub void decode_err<'a>(TranspileError<'a>& err, PathBuf& path) {
+pub void decode_err<'a>(TranspileError<'a>& err, PathBuf& path)
+{
     let curr_dir = std::env::current_dir().unwrap();
-
     match err {
         TranspileError::Semantic(e_list) => {
             for e in e_list {
-                eprintln!(
-                    "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}",
+                eprintln!("\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}",
                     path.strip_prefix(&curr_dir).unwrap_or_else(|_| path).as_os_str().display(),
                     e.line,
                     e.column,
-                    e.error_message,
-                );
+                    e.error_message,);
             }
         }
-
         TranspileError::Parse(e) => {
             match e {
                 error::ParseError::Ast(e) => {
                     let start_pos = e.span.start_pos().line_col();
-
                     let span = e.span.as_str();
-
-                    eprintln!(
-                        "\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}",
+                    eprintln!("\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}{}\t{}",
                         path.strip_prefix(curr_dir).unwrap_or_else(|_| path).as_os_str().display(),
                         start_pos.0,
                         start_pos.1,
                         e.error_message,
                         span,
                         if span.ends_with("\n") { "" } else { "\n" },
-                        "^".repeat(span.trim().len()),
-                    );
+                        "^".repeat(span.trim().len()),);
                 }
-
                 error::ParseError::PreAst(e) => {
                     eprintln!("error: parse failed in {}\n{}", path.strip_prefix(curr_dir).unwrap_or_else(|_| path).display(), e);
                 }

crates/parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-parser"
-version = "0.3.7-alpha.0"
+version = "0.3.8-alpha.0"
 edition = "2024"
 description = "The Mist programming language parser"
 license = "Apache-2.0"

crates/parser/src/ast/expr.rs

@@ -96,16 +96,6 @@ pub enum Generic {
     Type(TypeExpr),
 }
 
-impl Expression {
-    pub fn is_block(&self) -> bool {
-        if let Expression::Statement(stmt) = self {
-            stmt.is_block()
-        } else {
-            false
-        }
-    }
-}
-
 impl From<Path> for ExprPath {
     fn from(path: Path) -> Self {
         Self(
@@ -119,3 +109,23 @@ impl From<Path> for ExprPath {
         )
     }
 }
+
+impl Expression {
+    pub fn is_semicolon_required(&self) -> bool {
+        match self {
+            Self::Statement(v) => match &**v {
+                Statement::TopLevel(_) => false,
+                stmt => !stmt.is_block(),
+            },
+            _ => true,
+        }
+    }
+
+    pub fn is_block(&self) -> bool {
+        if let Expression::Statement(stmt) = self {
+            stmt.is_block()
+        } else {
+            false
+        }
+    }
+}

crates/parser/src/ast/statement.rs

@@ -12,6 +12,7 @@ pub struct Block {
 pub enum Statement {
     UnsafeBlock(Block),
     Block(Block),
+    TopLevel(Box<TopLevel>),
     If {
         initial: StatementBranch,
         else_if: Vec<StatementBranch>,

crates/parser/src/ast/top_level.rs

@@ -30,6 +30,13 @@ pub enum TopLevelKind {
     Import(Visibility, Path),
     DeclareModule(Visibility, Identifier),
     ImplDecl(ImplDecl),
+    StaticDecl(VarDeclStmt),
+    ConstDecl(VarDeclStmt),
+    TypeAlias {
+        name: Identifier,
+        generics: Option<GenericsDecl>,
+        ty: TypeExpr,
+    },
     TraitDecl {
         visibility: Visibility,
         name: Identifier,

crates/parser/src/grammar.pest

@@ -24,6 +24,7 @@ keyword = {
   | "class"
   | "trait"
   | "impl"
+  | "use"
   | "pub"
   | "mut"
   | "let"
@@ -33,6 +34,8 @@ keyword = {
   | "loop"
   | "unsafe"
   | "override"
+  | "const"
+  | "type"
 }
 
 identifier = @{
@@ -361,13 +364,24 @@ function_decl = {
     visibility? ~ ("void" | type_expr) ~ identifier ~ generics_decl? ~ "(" ~ method_args ~ ")" ~ override_kw? ~ (block | semicolon)
 }
 
+// ======================================================
+// CONSTANTS / STATIC
+// ======================================================
+const_decl  = { "const" ~ var_decl_statement ~ ";" }
+static_decl = { "static" ~ var_decl_statement ~ ";" }
+
+// ======================================================
+// Type aliases
+// ======================================================
+type_alias = { "type" ~ identifier ~ generics_decl? ~ "=" ~ type_expr ~ ";" }
+
 // ======================================================
 // TOP LEVEL
 // ======================================================
 
 top_level = {
     mod_attribute
-  | (attributes ~ (import | impl_for_decl | impl_decl | trait_decl | struct_decl | enum_decl | class_decl | declare_module | function_decl))
+  | (attributes ~ (import | impl_for_decl | impl_decl | trait_decl | struct_decl | enum_decl | class_decl | declare_module | function_decl | const_decl | static_decl | type_alias))
 }
 
 // ======================================================
@@ -388,6 +402,7 @@ statement_list = {
 
 statement = _{
     control_flow
+  | top_level
   | (expr ~ semicolon)
 }
 

crates/parser/src/parser/common/expr.rs

@@ -94,7 +94,8 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
             | Rule::basic_stmt
             | Rule::control_flow
             | Rule::block
-            | Rule::unsafe_block => Ok(Expression::Statement(Box::new(pair.try_into()?))),
+            | Rule::unsafe_block
+            | Rule::top_level => Ok(Expression::Statement(Box::new(pair.try_into()?))),
 
             _ => AstError::bug_unimplemented(pair),
         }

crates/parser/src/parser/common/statement.rs

@@ -51,6 +51,8 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
 
             Rule::block => Ok(Statement::Block(pair.try_into()?)),
 
+            Rule::top_level => Ok(Statement::TopLevel(Box::new(pair.try_into()?))),
+
             Rule::var_decl_statement => Ok(Statement::VarDecl(pair.try_into()?)),
 
             Rule::return_stmt => Ok(Statement::Return(

crates/parser/src/parser/items/mod.rs

@@ -122,6 +122,17 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TopLevelKind {
                 items: collect_recovered(&mut inner)?,
             }),
 
+            Rule::const_decl => Ok(TopLevelKind::ConstDecl(inner.next().unwrap().try_into()?)),
+            Rule::static_decl => Ok(TopLevelKind::StaticDecl(inner.next().unwrap().try_into()?)),
+
+            Rule::type_alias => Ok(TopLevelKind::TypeAlias {
+                name: inner.next().unwrap().try_into()?,
+                generics: consume_rule(&mut inner, Rule::generics_decl)
+                    .map(GenericsDecl::try_from)
+                    .transpose()?,
+                ty: inner.next().unwrap().try_into()?,
+            }),
+
             _ => AstError::bug_unimplemented(pair),
         }
     }

crates/parser/src/semantics.rs

@@ -129,6 +129,7 @@ impl GetMutability for Block {
 impl GetMutability for Statement {
     fn get_mutability(&self) -> Vec<Identifier> {
         match self {
+            Statement::TopLevel(_) => Vec::new(),
             Statement::Block(body) | Statement::UnsafeBlock(body) => body.get_mutability(),
             Statement::If {
                 initial,

mist-test/src/common/decl_test.mist

@@ -1,4 +1,5 @@
 pub module decl_test;
+pub module decl_test;
 
 pub void test_let_basic()
 {

mist-test/src/common/expr_test.mist

@@ -1,4 +1,5 @@
 pub module expr_test;
+pub module expr_test;
 
 pub void test_literals()
 {

mist-test/src/common/package.mist

@@ -1,3 +1,4 @@
+pub module package;
 pub module common;
 
 pub void test_package() {}

mist-test/src/common/statement_test.mist

@@ -1,4 +1,5 @@
 pub module statement_test;
+pub module statement_test;
 
 pub void test_var_decl()
 {

mist-test/src/common/types_test.mist

@@ -1,4 +1,5 @@
 pub module types_test;
+pub module types_test;
 
 pub void test_integer_type() {
     i32 x = 42;

mist-test/src/items/attribute_test.mist

@@ -1,4 +1,5 @@
 pub module attribute_test;
+pub module attribute_test;
 
 #[derive(Debug)]
 pub struct Debuggable

mist-test/src/items/class_test.mist

@@ -1,4 +1,5 @@
 pub module class_test;
+pub module class_test;
 
 pub class Animal
 {

mist-test/src/items/enum_test.mist

@@ -1,4 +1,5 @@
 pub module enum_test;
+pub module enum_test;
 
 enum OptionInt
 {

mist-test/src/items/function_test.mist

@@ -1,4 +1,5 @@
 pub module function_test;
+pub module function_test;
 
 void greet()
 {

mist-test/src/items/impl_test.mist

@@ -1,4 +1,5 @@
 pub module impl_test;
+pub module impl_test;
 
 struct Vector2
 {

mist-test/src/items/struct_test.mist

@@ -1,4 +1,5 @@
 pub module struct_test;
+pub module struct_test;
 
 struct Point
 {

mist-test/src/items/trait_test.mist

@@ -1,4 +1,5 @@
 pub module trait_test;
+pub module trait_test;
 
 trait Speak
 {

src/analyzer.mist

@@ -1,3 +1,4 @@
-void main() {
+void main()
+{
     mist_analyzer::start();
 }

src/main.mist

@@ -1,23 +1,26 @@
 use std::process;
+
 use std::env;
+
 use std::fs;
+
 use mist_api::builder;
+
 use mist_api::transpiler;
 
-void main() {
-    Vec<String> args = env::args().collect();
-
+void main()
+{
+    Vec<String> mut args = env::args().collect();
     if args.len() < 2 {
         print_usage();
         process::exit(1);
     }
-
     match args[1].as_str() {
-        "run" | "build" | "check" | "r" | "b" | "c" => {
-            let root = transpiler::transpile();
-
+        "run" | "build" | "check" | "test" | "publish" | "bench" | "doc" | "fix" | "clippy" | "r" | "b" | "c" => {
+            let mut root = env::current_dir().expect("Unable to find project root");
+            modify_args(&mut args, &mut root);
+            transpiler::transpile(&root);
             println!("");
-
             if builder::build(args, root) {
                 println!("\x1b[32m\nBuild successful\x1b[0m");
             } else {
@@ -25,11 +28,20 @@ void main() {
             }
         }
         "transpile" | "t" => {
-            transpiler::transpile();
+            let mut root = env::current_dir().expect("Unable to find project root");
+            modify_args(&mut args, &mut root);
+            transpiler::transpile(&root);
+        }
+        "clean" => {
+            args.remove(0);
+            process::Command::new("cargo").args(args).stdout(process::Stdio::inherit()).stderr(process::Stdio::inherit()).stdin(process::Stdio::inherit()).spawn().expect("Failed to run cargo").wait().expect("Unable to wait");
         }
         "init" => {
             init_project(args);
         }
+        "new" => {
+            new_project(args);
+        }
         "version" | "--version" | "-v" => {
             println!("mist {}", env!("CARGO_PKG_VERSION"));
         }
@@ -44,62 +56,123 @@ void main() {
     }
 }
 
-void print_usage() {
-    println!("Mist - the mist compiler\n");
-    println!("󰖟 View our documentation! \x1b[35mhttps://mist.selimaj.dev\x1b[0m");
-    println!(" Follow us on github!    \x1b[35mhttps://github.com/mist-go\x1b[0m\n");
-    println!("usage:");
-    println!(" \x1b[36m mist run\x1b[0m,\x1b[36m r\x1b[0m            run the project in the current directory\n");
-    println!(
-        " \x1b[36m mist build\x1b[0m,\x1b[36m b\x1b[0m          build the project in the current directory\n"
-    );
-    println!(
-        " \x1b[36m mist transpile\x1b[0m,\x1b[36m t\x1b[0m      transpile the project in the current directory\n"
-    );
-    println!(
-        " \x1b[36m mist check\x1b[0m,\x1b[36m c\x1b[0m          check the project in the current directory\n"
-    );
-    println!(
-        " \x1b[36m mist init\x1b[0m              initialize a project in the current folder\n"
-    );
-    println!(" \x1b[36m mist version \x1b[0m          print the compiler version\n");
-    println!(" \x1b[36m mist help\x1b[0m              print this message\n");
+void modify_args(Vec<String> mut& args, std::path::PathBuf mut& root)
+{
+    if let Some(path_arg) = args.get(2) {
+        if path_arg == "--path" {
+            if args.len() > 3 {
+                let path_arg = args[3].clone();
+                *root = root.join(&path_arg);
+                args.remove(2);
+                args.remove(2);
+                args.push(format!("--manifest-path={}/Cargo.toml", root.display()));
+            }
+        }
+    }
 }
 
-void init_project(Vec<String> mut args) {
+void print_usage()
+{
+    println!("Mist - the mist compiler\n");
+    println!("󰖟 View our documentation! \x1b[95mhttps://mist.selimaj.dev\x1b[0m");
+    println!(" Follow us on github!    \x1b[95mhttps://github.com/mist-go\x1b[0m\n");
+    println!("usage:");
+    println!(" \x1b[96m mist run\x1b[0m,\x1b[96m r\x1b[0m            run the project\n");
+    println!(" \x1b[96m mist build\x1b[0m,\x1b[96m b\x1b[0m          build the project\n");
+    println!(" \x1b[96m mist test\x1b[0m              test the project\n");
+    println!(" \x1b[96m mist publish\x1b[0m           publish the project\n");
+    println!(" \x1b[96m mist bench\x1b[0m             benchmark the project\n");
+    println!(" \x1b[96m mist doc\x1b[0m               build documentation\n");
+    println!(" \x1b[96m mist fix\x1b[0m               automatically fix warnings\n");
+    println!(" \x1b[96m mist clippy\x1b[0m            lint the project\n");
+    println!(" \x1b[96m mist check\x1b[0m,\x1b[96m c\x1b[0m          check the project\n");
+    println!(" \x1b[96m mist clean\x1b[0m             clean build artifacts\n");
+    println!(" \x1b[96m mist transpile\x1b[0m,\x1b[96m t\x1b[0m      transpile the project\n");
+    println!(" \x1b[96m mist init\x1b[0m              initialize a project in the current folder\n");
+    println!(" \x1b[96m mist new\x1b[0m               create a new project\n");
+    println!(" \x1b[96m mist version \x1b[0m          print the compiler version\n");
+    println!(" \x1b[96m mist help\x1b[0m              print this message\n");
+}
+
+void init_project(Vec<String> mut args)
+{
     args.remove(0);
-
-    process::Command::new("cargo")
-        .args(args)
-        .stdout(process::Stdio::inherit())
-        .stderr(process::Stdio::inherit())
-        .stdin(process::Stdio::inherit())
-        .spawn()
-        .expect("Failed to run cargo").wait().expect("Unable to wait");
-
+    let status = process::Command::new("cargo").args(args).stdout(process::Stdio::inherit()).stderr(process::Stdio::inherit()).stdin(process::Stdio::inherit()).spawn().expect("Failed to run cargo").wait().expect("Unable to wait");
+    if !status.success() {
+        return;
+    }
     bool is_lib = fs::metadata("src/lib.rs").is_ok();
-
     if is_lib {
         fs::remove_file("src/lib.rs").expect("Failed to remove src/lib.rs");
-        fs::write("src/lib.mist", "fn test() {\n}").expect("Failed to create src/lib.mist");
+        fs::write("src/lib.mist", "void test() {\n}").expect("Failed to create src/lib.mist");
     } else {
         fs::remove_file("src/main.rs").expect("Failed to remove src/main.rs");
-        fs::write("src/main.mist", "fn main() {\n    println!(\"Hello, World!\");\n}\n").expect("Failed to create src/main.mist");
+        fs::write("src/main.mist", "void main() {\n    println!(\"Hello, World!\");\n}\n").expect("Failed to create src/main.mist");
     }
-
     inject_mist_target(is_lib);
-
-    println!("\n\x1b[34minfo\x1b[0m: Please open Cargo.toml and adjust `\x1b[35mname\x1b[0m = ` as needed, Thank you for using Mist!\n");
+    add_mist_toml(is_lib);
+    add_gitignore();
+    println!("Thank you for using Mist!\n");
 }
 
-void inject_mist_target(bool is_lib) {
-    String toml_content = fs::read_to_string("Cargo.toml").expect("Failed to read Cargo.toml");
-
-    str& inject = if is_lib {
-        "\n[lib]\nname = \"my_lib\"\npath = \".mist/src/lib.rs\"\n"
+void new_project(Vec<String> mut args)
+{
+    args.remove(0);
+    if args.len() < 2 {
+        eprintln!("error: missing project name\n");
+        print_usage();
+        process::exit(1);
+    }
+    String project_name = args[1].clone();
+    let status = process::Command::new("cargo").args(args).stdout(process::Stdio::inherit()).stderr(process::Stdio::inherit()).stdin(process::Stdio::inherit()).spawn().expect("Failed to run cargo").wait().expect("Unable to wait");
+    if !status.success() {
+        return;
+    }
+    std::path::PathBuf project_path = env::current_dir().expect("Unable to find project root").join(&project_name);
+    env::set_current_dir(&project_path).expect("Failed to change to project directory");
+    bool is_lib = fs::metadata("src/lib.rs").is_ok();
+    if is_lib {
+        fs::remove_file("src/lib.rs").expect("Failed to remove src/lib.rs");
+        fs::write("src/lib.mist", "void test() {\n}").expect("Failed to create src/lib.mist");
     } else {
-        "\n[[bin]]\nname = \"my_bin\"\npath = \".mist/src/main.rs\"\n"
+        fs::remove_file("src/main.rs").expect("Failed to remove src/main.rs");
+        fs::write("src/main.mist", "void main() {\n    println!(\"Hello, World!\");\n}\n").expect("Failed to create src/main.mist");
+    }
+    inject_mist_target(is_lib);
+    add_mist_toml(is_lib);
+    add_gitignore();
+    println!("Thank you for using Mist!\n");
+}
+
+void inject_mist_target(bool is_lib)
+{
+    String toml_content = fs::read_to_string("Cargo.toml").expect("Failed to read Cargo.toml");
+    toml::Value parsed = toml::from_str(&toml_content).expect("Failed to parse Cargo.toml");
+    String name = parsed["package"]["name"].as_str().expect("Missing package.name in Cargo.toml").to_string();
+    String inject = if is_lib {
+        format!("\n[lib]\nname = \"{name}\"\npath = \".mist/src/lib.rs\"\n")
+    } else {
+        format!("\n[[bin]]\nname = \"{name}\"\npath = \".mist/src/main.rs\"\n")
+    };
+    fs::write("Cargo.toml", toml_content + &inject).expect("Failed to inject to Cargo.toml");
+}
+
+void add_mist_toml(bool is_lib)
+{
+    str& content = if is_lib {
+        "package = \"lib.mist\"\npackages = []\ninclude = []\n"
+    } else {
+        "package = \"main.mist\"\npackages = []\ninclude = []\n"
     };
+    fs::write("Mist.toml", content).expect("Failed to add Mist.toml");
+}
 
-    fs::write("Cargo.toml", toml_content+inject).expect("Failed to inject to Cargo.toml");
+void add_gitignore()
+{
+    if fs::metadata(".gitignore").is_ok() {
+        String content = fs::read_to_string(".gitignore").expect("Failed to read .gitignore");
+        if !content.contains(".mist") {
+            fs::write(".gitignore", content + "\n.mist\n").expect("Failed to write .gitignore");
+        }
+    }
 }