Bump to full release

Patches

Cargo.lock

@@ -476,7 +476,7 @@ dependencies = [
 
 [[package]]
 name = "mist-analyzer"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 dependencies = [
  "cargo_metadata",
  "dashmap 6.1.0",
@@ -495,7 +495,7 @@ dependencies = [
 
 [[package]]
 name = "mist-api"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 dependencies = [
  "cargo_metadata",
  "mist-codegen",
@@ -507,7 +507,7 @@ dependencies = [
 
 [[package]]
 name = "mist-codegen"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 dependencies = [
  "bytecount",
  "mist-parser",
@@ -515,15 +515,16 @@ dependencies = [
 
 [[package]]
 name = "mist-lang"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 dependencies = [
  "mist-analyzer",
  "mist-api",
+ "toml",
 ]
 
 [[package]]
 name = "mist-parser"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 dependencies = [
  "pest",
  "pest_derive",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-lang"
-version = "0.3.7-alpha.1"
+version = "0.4.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.1" }
+mist-parser = { path = "crates/parser", version = "0.4.0" }
-mist-analyzer = { path = "crates/analyzer", version = "0.3.7-alpha.1" }
+mist-analyzer = { path = "crates/analyzer", version = "0.4.0" }
-mist-codegen = { path = "crates/codegen", version = "0.3.7-alpha.1" }
+mist-codegen = { path = "crates/codegen", version = "0.4.0" }
-mist-api = { path = "crates/mist-api", version = "0.3.7-alpha.1" }
+mist-api = { path = "crates/mist-api", version = "0.4.0" }
 
 [[bin]]
 name = "mist"

README.md

@@ -5,7 +5,7 @@ Originally this readme was part of the Carbon Language project, licensed with Ap
 -->
 
 <p align="center">
-  <a href="https://mist.selimaj.dev">Documentation</a>
+  <a href="https://mist.selimaj.dev/docs">Documentation</a> ∙ <a href="https://mist.selimaj.dev/blog">Blog</a> ∙ <a href="https://mist.selimaj.dev/faq">FAQ</a>
 </p>
 
 

crates/analyzer/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-analyzer"
-version = "0.3.7-alpha.1"
+version = "0.4.0"
 edition = "2024"
 description = "The Mist programming language Analyzer LSP"
 license = "Apache-2.0"

crates/analyzer/src/lib.rs

@@ -10,6 +10,7 @@ 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;
@@ -25,7 +26,7 @@ use crate::transpiler::{
 
 static MARKER_COUNTER: AtomicU64 = AtomicU64::new(0);
 
-const KEYWORDS: [&'static str; 22] = [
+const KEYWORDS: [&'static str; 23] = [
     "if",
     "else",
     "for",
@@ -48,6 +49,7 @@ const KEYWORDS: [&'static str; 22] = [
     "override",
     "module ",
     "void ",
+    "virtual ",
 ];
 
 fn keyword_completion_items() -> impl Iterator<Item = CompletionItem> {
@@ -91,12 +93,12 @@ fn clean_lsp_url(path: &std::path::Path) -> Option<Url> {
 }
 
 fn lsp_pos_to_rust_map(pos: &Position) -> RustMap {
-    RustMap(pos.line as usize + 1, pos.character as usize)
+    RustMap(pos.line as usize, pos.character as usize)
 }
 
 fn mist_map_to_lsp_pos(map: &MistMap) -> Position {
     Position {
-        line: map.0.saturating_sub(1) as u32,
+        line: map.0 as u32,
         character: map.1 as u32,
     }
 }
@@ -389,7 +391,7 @@ impl Backend {
                 // Fallback: the source has a syntax error that prevents transpilation.
                 // Use the last known working Rust content + mapping to inject the
                 // marker at the nearest valid Rust position.
-                let mist_target = MistMap(line as usize + 1, character as usize);
+                let mist_target = MistMap(line as usize, character as usize);
                 let mut rust_path = crate::from_mist_to_rust(mist_path.to_path_buf());
                 if mist_path.file_name().and_then(|n| n.to_str()) == Some("package.mist") {
                     rust_path.set_file_name("mod.rs");
@@ -415,7 +417,7 @@ impl Backend {
                     .map(|(rust, _)| *rust);
 
                 let (modified_rust, rust_pos) = if let Some(next_rust) = rust_next {
-                    let lsp_line = (next_rust.0 - 1) as u32;
+                    let lsp_line = next_rust.0 as u32;
                     let lsp_col = next_rust.1 as u32;
                     let modified = inject_marker_at(&last_content, lsp_line, lsp_col, &marker)?;
                     let pos = find_marker_position(&modified, &marker)?;
@@ -602,6 +604,59 @@ impl Backend {
             None => return,
         };
 
+        // Prune documents whose source files no longer exist on disk.
+        // Without this, deleted .mist files linger in the in-memory map
+        // and compute_mod_decls keeps generating stale pub mod declarations.
+        // Also clean up stale synthetic package.mist entries and generated
+        // mod.rs output files for directories with no remaining source children.
+        {
+            let mut docs = self.documents.lock().await;
+            let stale: Vec<PathBuf> = docs
+                .keys()
+                .filter(|p| !p.exists())
+                .cloned()
+                .collect();
+            for path in &stale {
+                docs.remove(path);
+                if path.extension().and_then(|e| e.to_str()) == Some("mist") {
+                    let rust_path = mist_to_rust_path(path);
+                    let _ = std::fs::remove_file(&rust_path);
+                    let map_path = rust_path.with_extension("map.json");
+                    let _ = std::fs::remove_file(&map_path);
+                }
+            }
+
+            // Also remove synthetic package.mist entries whose directories
+            // no longer contain any real .mist source files.
+            let synthetic: Vec<PathBuf> = docs
+                .keys()
+                .filter(|p| {
+                    p.file_name().and_then(|n| n.to_str()) == Some("package.mist")
+                        && !p.exists()
+                })
+                .cloned()
+                .collect();
+            for path in &synthetic {
+                docs.remove(path);
+            }
+
+            drop(docs);
+
+            // Clean up auxiliary state for deleted files
+            let mut versions = self.doc_versions.lock().await;
+            let mut contents = self.last_rust_contents.lock().await;
+            let mut diags = self.previous_diagnostics.lock().await;
+            let all_stale: Vec<PathBuf> = stale.into_iter().chain(synthetic).collect();
+            let stale_set: std::collections::HashSet<_> = all_stale.iter().collect();
+            versions.retain(|k, _| !stale_set.contains(k));
+            contents.retain(|k, _| !stale_set.contains(k));
+            for path in &all_stale {
+                if let Some(uri) = clean_lsp_url(path) {
+                    diags.remove(&uri);
+                }
+            }
+        }
+
         self.ensure_implicit_packages().await;
 
         // Collect sources first to avoid holding locks during transpile
@@ -617,7 +672,11 @@ impl Backend {
                 let package_mist = read_mist_package(crate_root);
                 let mod_decls = compute_mod_decls(&docs, &src_root, &package_mist);
                 for (path, decl) in mod_decls {
-                    if !decl.is_empty() {
+                    // Include files that have mod declarations OR that are
+                    // already known package/directory entries in the doc map.
+                    // The latter case covers parents whose children were
+                    // deleted — they need a regenerated (empty) mod.rs.
+                    if !decl.is_empty() || docs.contains_key(&path) {
                         if let Some(source) = docs.get(&path) {
                             result.push((path.clone(), source.to_string(), decl));
                         }
@@ -1119,13 +1178,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(
@@ -1162,6 +1218,11 @@ impl LanguageServer for Backend {
             return Ok(None);
         };
 
+        let trigger_char: Option<String> = params
+            .context
+            .as_ref()
+            .and_then(|c| c.trigger_character.clone());
+
         let comp_params = CompletionParams {
             text_document_position: TextDocumentPositionParams {
                 text_document: TextDocumentIdentifier { uri: rust_uri },
@@ -1189,13 +1250,13 @@ impl LanguageServer for Backend {
 
         match completion_result {
             Ok(Some(CompletionResponse::Array(mut items))) => {
-                mist_ify_completions(&source, &mist_pos, &mut items);
+                mist_ify_completions(&source, &mist_pos, &mut items, trigger_char.as_deref());
 
                 Ok(Some(CompletionResponse::Array(items)))
             }
 
             Ok(Some(CompletionResponse::List(mut list))) => {
-                mist_ify_completions(&source, &mist_pos, &mut list.items);
+                mist_ify_completions(&source, &mist_pos, &mut list.items, trigger_char.as_deref());
 
                 Ok(Some(CompletionResponse::List(list)))
             }
@@ -1490,10 +1551,8 @@ impl LanguageServer for Backend {
     }
 }
 
-fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<CompletionItem>) {
+fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<CompletionItem>, trigger_char: Option<&str>) {
-    let existing: HashSet<String> = items.iter().map(|item| item.label.clone()).collect();
+    let is_scoping_trigger = matches!(trigger_char, Some("." | ":"));
-
-    items.extend(keyword_completion_items().filter(|item| !existing.contains(&item.label)));
 
     for item in items.iter_mut() {
         item.text_edit = None;
@@ -1505,6 +1564,14 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         }
     }
 
+    if is_scoping_trigger {
+        return;
+    }
+
+    let existing: HashSet<String> = items.iter().map(|item| item.label.clone()).collect();
+
+    items.extend(keyword_completion_items().filter(|item| !existing.contains(&item.label)));
+
     let curr_scope = current_scope(&source, pos.line, pos.character);
 
     // =========================
@@ -1632,11 +1699,11 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
     // Struct/Class
     // =========================
 
-    if matches!(curr_scope, Scope::Struct) {
+    if matches!(curr_scope, Scope::Class) {
         items.push(CompletionItem {
-            label: "field".into(),
+            label: "virtual".into(),
             kind: Some(CompletionItemKind::SNIPPET),
-            insert_text: Some("$1 $2,".into()),
+            insert_text: Some("pub virtual $1 $2()\n{\n\t$3\n}".into()),
             insert_text_format: Some(InsertTextFormat::SNIPPET),
             sort_text: Some("0000".into()),
             preselect: Some(true),
@@ -1644,9 +1711,19 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         });
 
         items.push(CompletionItem {
-            label: "pub field".into(),
+            label: "override".into(),
             kind: Some(CompletionItemKind::SNIPPET),
-            insert_text: Some("pub $1 $2,".into()),
+            insert_text: Some("$1 $2() override$3\n{\n\t$4\n}".into()),
+            insert_text_format: Some(InsertTextFormat::SNIPPET),
+            sort_text: Some("0000".into()),
+            preselect: Some(true),
+            ..Default::default()
+        });
+
+        items.push(CompletionItem {
+            label: "virtual override".into(),
+            kind: Some(CompletionItemKind::SNIPPET),
+            insert_text: Some("pub virtual $1 $2() override$3\n{\n\t$4\n}".into()),
             insert_text_format: Some(InsertTextFormat::SNIPPET),
             sort_text: Some("0000".into()),
             preselect: Some(true),
@@ -1654,7 +1731,8 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         });
     }
 
-    if matches!(curr_scope, Scope::Class) {
+
+    if matches!(curr_scope, Scope::Class | Scope::Struct) {
         items.push(CompletionItem {
             label: "field".into(),
             kind: Some(CompletionItemKind::SNIPPET),
@@ -1684,7 +1762,7 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         items.push(CompletionItem {
             label: "variant".into(),
             kind: Some(CompletionItemKind::SNIPPET),
-            insert_text: Some("$1,".into()),
+            insert_text: Some("$1;".into()),
             insert_text_format: Some(InsertTextFormat::SNIPPET),
             sort_text: Some("0000".into()),
             preselect: Some(true),
@@ -1694,7 +1772,7 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         items.push(CompletionItem {
             label: "tuple variant".into(),
             kind: Some(CompletionItemKind::SNIPPET),
-            insert_text: Some("$1($2),".into()),
+            insert_text: Some("$1($2);".into()),
             insert_text_format: Some(InsertTextFormat::SNIPPET),
             sort_text: Some("0000".into()),
             preselect: Some(true),
@@ -1704,7 +1782,7 @@ fn mist_ify_completions(source: &str, pos: &Position, items: &mut Vec<Completion
         items.push(CompletionItem {
             label: "struct variant".into(),
             kind: Some(CompletionItemKind::SNIPPET),
-            insert_text: Some("$1\n{\n\t$0\n},".into()),
+            insert_text: Some("$1\n{\n\t$0\n};".into()),
             insert_text_format: Some(InsertTextFormat::SNIPPET),
             sort_text: Some("0000".into()),
             preselect: Some(true),
@@ -1859,7 +1937,7 @@ async fn handle_ra_notifications(
                                     character: if mist_end_pos.line == mist_start_pos.line {
                                         mist_end_pos.character.max(mist_start_pos.character + 1)
                                     } else {
-                                        mist_end_pos.character.max(1)
+                                        mist_end_pos.character.max(0)
                                     },
                                 };
 
@@ -2009,20 +2087,27 @@ 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/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> {
+pub fn format_mist(source: &str, _config: MistFmtConfig) -> Result<String, String> {
-    let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
+    // let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
 
-    let mut codegen = MistCodegen::new(config);
+    // let mut codegen = MistCodegen::new(config);
-    codegen.generate(parsed.mod_attributes);
+    // codegen.generate(parsed.mod_attributes);
-    let output = codegen.generate(parsed.items);
+    // 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.1"
+version = "0.4.0"
 edition = "2024"
 description = "The Mist programming language Rust code generator"
 license = "Apache-2.0"

crates/codegen/src/class_decl.rs

@@ -16,7 +16,7 @@ pub struct ClassProcessedData {
     items: Vec<ClassItem>,
     methods: Vec<Spanned<FunctionDecl>>,
     v_table: Vec<Identifier>,
-    override_v_table: HashMap<Override, Spanned<Vec<Identifier>>>,
+    override_v_table: HashMap<Override, Spanned<Vec<(Identifier, bool)>>>,
 }
 
 impl ClassProcessedData {
@@ -45,13 +45,13 @@ impl ClassProcessedData {
             .collect::<Vec<Spanned<FunctionDecl>>>();
 
         let mut v_table = Vec::new();
-        let mut override_v_table = std::collections::HashMap::new();
+        let mut override_v_table = HashMap::new();
 
         for method in &methods {
             if matches!(method.item.visibility, Visibility::Public) {
                 match &method.item.is_override {
                     None => {
-                        if method.item.self_param.is_some() {
+                        if method.item.is_virtual && method.item.self_param.is_some() {
                             v_table.push(method.item.name.clone());
                         }
                     }
@@ -64,7 +64,7 @@ impl ClassProcessedData {
                                 item: Vec::new(),
                             })
                             .item
-                            .push(method.item.name.clone());
+                            .push((method.item.name.clone(), method.item.is_virtual));
                     }
                 }
             }
@@ -113,7 +113,7 @@ impl ClassProcessedData {
             cg.add(&get_type_from_path(inherits).get_rust());
             cg.addln(",");
         } else {
-            cg.add_indentedln("pub _vptr: &'static [*const std::ffi::c_void],");
+            cg.add_indentedln("pub _vptr: &'static [*const core::ffi::c_void],");
         }
 
         for field in &self.fields {
@@ -174,11 +174,11 @@ impl ClassProcessedData {
             self.v_table.len()
         ));
 
-        cg.add_indentedln("pub const __V_TABLE: &'static [*const std::ffi::c_void] = &{");
+        cg.add_indentedln("pub const __V_TABLE: &'static [*const core::ffi::c_void] = &{");
         cg.indent += 1;
 
         if has_parent {
-            cg.add_indentedln("let mut table = [std::ptr::null(); Self::__V_COUNT];");
+            cg.add_indentedln("let mut table = [core::ptr::null(); Self::__V_COUNT];");
 
             cg.add_indentedln(&format!("let parent_table = {}::__V_TABLE;", parent_path));
             cg.add_indentedln(
@@ -191,20 +191,20 @@ impl ClassProcessedData {
                     .as_ref()
                     .unwrap_or(self.inherits.as_ref().unwrap())
                     .get_rust();
-                for method_ident in &overriden_method_idents.item {
+                for (method_ident, is_virtual) in &overriden_method_idents.item {
                     cg.add_indentedln(&format!(
-                        "table[{}::__FN_{}] = {}::__m_{} as *const std::ffi::c_void;",
+                        "table[{}::__FN_{}] = {}::{} as *const core::ffi::c_void;",
                         base_class_path,
                         method_ident.0.to_uppercase(),
                         self.self_path.get_rust(),
-                        method_ident.get_rust()
+                        get_virtual_name(method_ident, *is_virtual)
                     ));
                 }
             }
 
             for method_name in &self.v_table {
                 cg.add_indentedln(&format!(
-                    "table[Self::__FN_{}] = Self::__m_{} as *const std::ffi::c_void;",
+                    "table[Self::__FN_{}] = Self::__m_{} as *const core::ffi::c_void;",
                     method_name.0.to_uppercase(),
                     method_name.get_rust()
                 ));
@@ -216,7 +216,7 @@ impl ClassProcessedData {
             cg.indent += 1;
             for method_name in &self.v_table {
                 cg.add_indentedln(&format!(
-                    "Self::__m_{} as *const std::ffi::c_void,",
+                    "Self::__m_{} as *const core::ffi::c_void,",
                     method_name.get_rust()
                 ));
             }
@@ -293,7 +293,7 @@ impl ClassProcessedData {
 
         // Deref tests for override targets
         if self.inherits.is_some() && !self.override_v_table.is_empty() {
-            cg.add_indentedln("let this: &Self = &unsafe { std::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
+            cg.add_indentedln("let this: &Self = &unsafe { core::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
 
             for (override_tier, v) in &self.override_v_table {
                 if let Some(path) = &override_tier.0 {
@@ -346,14 +346,15 @@ impl ClassProcessedData {
         cg.addln(") -> Self {");
         cg.indent += 1;
 
-        cg.add_indentedln("let mut this: Self = unsafe { std::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
+        cg.add_indentedln("let mut this: Self = unsafe { core::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
         cg.add_indentedln("this._vptr = &Self::__V_TABLE;");
 
         for field in &self.fields {
             if let Some(init) = &field.item.init {
                 field.gen_span(cg);
-                cg.add_indentedln(&format!("this.{} = ", field.item.decl.name.get_rust()));
+                cg.add_indented(&format!("this.{} = ", field.item.decl.name.get_rust()));
                 init.gen_rust(ctx, cg);
+                cg.addln(";");
             }
         }
 
@@ -362,7 +363,6 @@ impl ClassProcessedData {
             if *i > 0 {
                 cg.add(", ");
             }
-            ctx.expr_ensure_semicolon = false;
             param.name.gen_rust(ctx, cg);
         }
         cg.addln(");");
@@ -380,6 +380,7 @@ impl ClassProcessedData {
             column: constructor.column,
             item: FunctionDecl {
                 visibility: constructor.item.visibility.clone(),
+                is_virtual: false,
                 is_override: None,
                 name: Identifier(String::from("constructor")),
                 generics: constructor.item.generics.clone(),
@@ -396,7 +397,7 @@ impl ClassProcessedData {
         for method in &self.methods {
             match method.item.visibility {
                 Visibility::Public => {
-                    if method.item.self_param.is_some() {
+                    if method.item.is_virtual && method.item.self_param.is_some() {
                         if method.item.is_override.is_none() {
                             gen_method_point(&method.item, ctx, cg);
                         }
@@ -432,7 +433,7 @@ impl ClassProcessedData {
             let generics_expr_str = Generics::from(self.generics.clone()).get_rust();
 
             cg.add(&format!(
-                "impl{} std::ops::Deref for {}{}",
+                "impl{} core::ops::Deref for {}{}",
                 generics_str,
                 self.name.get_rust(),
                 generics_expr_str
@@ -451,7 +452,7 @@ impl ClassProcessedData {
             cg.addln("}");
 
             cg.add(&format!(
-                "impl{} std::ops::DerefMut for {}{}",
+                "impl{} core::ops::DerefMut for {}{}",
                 generics_str,
                 self.name.get_rust(),
                 generics_expr_str
@@ -579,7 +580,7 @@ pub fn gen_method_point(method: &FunctionDecl, ctx: &mut Context, cg: &mut RustC
             mutable: mutable_self,
             ty: Box::new(TypeExpr::Path(
                 Path(vec![
-                    Identifier(String::from("std")),
+                    Identifier(String::from("core")),
                     Identifier(String::from("ffi")),
                     Identifier(String::from("c_void")),
                 ]),
@@ -589,17 +590,16 @@ pub fn gen_method_point(method: &FunctionDecl, ctx: &mut Context, cg: &mut RustC
     );
 
     cg.add(&TypeExpr::StaticFn(param_types, method.return_type.clone().map(Box::new)).get_rust());
-    cg.addln(" = std::mem::transmute(func_ptr);");
+    cg.addln(" = core::mem::transmute(func_ptr);");
 
     if mutable_self {
-        cg.add_indented("func(self as *mut Self as *const std::ffi::c_void");
+        cg.add_indented("func(self as *mut Self as *const core::ffi::c_void");
     } else {
-        cg.add_indented("func(self as *const Self as *const std::ffi::c_void");
+        cg.add_indented("func(self as *const Self as *const core::ffi::c_void");
     }
 
     for (_, param) in &params {
         cg.add(", ");
-        ctx.expr_ensure_semicolon = false;
         param.name.gen_rust(ctx, cg);
     }
 
@@ -618,3 +618,11 @@ pub fn get_type_from_path(path: &ExprPath) -> TypeExpr {
         path.0.last().unwrap().generics.clone(),
     )
 }
+
+pub fn get_virtual_name(name: &Identifier, is_virtual: bool) -> String {
+    if is_virtual {
+        format!("__m_{}", name.get_rust())
+    } else {
+        name.get_rust()
+    }
+}

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,10 +1,9 @@
 pub mod class_decl;
 pub mod expr;
-pub mod fmt;
 pub mod statement;
 pub mod top_level;
 
-use std::path::PathBuf;
+use std::{collections::HashMap, path::PathBuf};
 
 use mist_parser::{
     ast::*,
@@ -12,7 +11,6 @@ use mist_parser::{
 };
 
 pub struct Context {
-    pub expr_ensure_semicolon: bool,
     pub expr_super: Option<ExprPath>,
 }
 
@@ -28,9 +26,15 @@ pub trait GetRust {
     }
 }
 
+pub enum Include {
+    Glob(Path),
+    Use(Visibility, Path),
+}
+
 pub struct RustCodegen {
     output: String,
     indent: usize,
+    pub crates: HashMap<Identifier, Vec<Include>>,
     pub mapping: Mapping,
     position: RustMap,
 }
@@ -40,8 +44,9 @@ impl RustCodegen {
         Self {
             output: String::new(),
             indent: 0,
+            crates: HashMap::new(),
             mapping: Mapping::new(mist_path),
-            position: RustMap(1, 0),
+            position: RustMap(0, 0),
         }
     }
 
@@ -80,15 +85,45 @@ impl RustCodegen {
     }
 
     pub fn generate(&mut self, toplevels: Vec<TopLevel>) -> String {
-        let mut ctx = Context {
+        let mut ctx = Context { expr_super: None };
-            expr_ensure_semicolon: true,
-            expr_super: None,
-        };
 
         for tl in toplevels {
             tl.gen_rust(&mut ctx, self);
         }
 
+        let mut crates = HashMap::new();
+        std::mem::swap(&mut self.crates, &mut crates);
+
+        for (c, items) in crates {
+            self.add("mod ");
+            c.gen_rust(&mut ctx, self);
+            self.addln(" {");
+            self.indent += 1;
+
+            self.add_indented("extern crate ");
+            c.gen_rust(&mut ctx, self);
+            self.addln(";");
+
+            for item in items {
+                self.add_indentedln("#[doc(inline)]");
+                self.add_indented("pub use ");
+                match item {
+                    Include::Glob(item) => {
+                        item.gen_rust(&mut ctx, self);
+                        self.add("::*");
+                    }
+                    Include::Use(vis, item) => {
+                        vis.gen_rust(&mut ctx, self);
+                        item.gen_rust(&mut ctx, self);
+                    }
+                }
+                self.addln(";");
+            }
+
+            self.indent -= 1;
+            self.addln("}");
+        }
+
         self.output.clone()
     }
 
@@ -151,7 +186,7 @@ impl<T> GenSpanTranslation for Spanned<T> {
     fn gen_span(&self, cg: &mut RustCodegen) {
         cg.mapping
             .map
-            .insert((cg.position, MistMap(self.line, self.column)));
+            .insert((cg.position, MistMap(self.line, self.column - 1)));
     }
 }
 
@@ -204,7 +239,6 @@ impl GetRust for TypeExpr {
                     path.get_rust()
                 }
             }
-            Self::Lifetime(name) => format!("'{}", name.get_rust()),
             Self::Tuple(types) => format!(
                 "({})",
                 types
@@ -278,6 +312,13 @@ impl GetRust for TypeExpr {
                     return_type.get_rust(),
                 )
             }
+            Self::Array(ty, count) => {
+                if let Some(count) = count {
+                    format!("[{}; {count}]", ty.get_rust())
+                } else {
+                    format!("[{}]", ty.get_rust())
+                }
+            }
         }
     }
 }

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;
@@ -185,14 +188,41 @@ impl GenRust for Statement {
 
 impl GenRust for VarDecl {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        self.name.gen_rust(ctx, cg);
+        if self.tuple_names.is_empty() {
+            self.name.gen_rust(ctx, cg);
+        } else {
+            cg.add("(");
+            self.name.gen_rust(ctx, cg);
+            for name in &self.tuple_names {
+                cg.add(", ");
+                name.gen_rust(ctx, cg);
+            }
+            cg.add(")");
+        }
 
-        cg.add(
+        if self.true_type {
-            &self
+            cg.add(
-                .type_
+                &self
-                .as_ref()
+                    .type_
-                .map(|t| format!(": {}", t.get_rust()))
+                    .as_ref()
-                .unwrap_or_default(),
+                    .map(|t| format!(": {}", t.get_rust()))
-        );
+                    .unwrap_or_default(),
+            );
+        } else {
+            cg.add(
+                &self
+                    .type_
+                    .as_ref()
+                    .map(|t| {
+                        let t = vec![t.get_rust(); self.tuple_names.len() + 1];
+                        if self.tuple_names.is_empty() {
+                            format!(": {}", t.join(", "))
+                        } else {
+                            format!(": ({})", t.join(", "))
+                        }
+                    })
+                    .unwrap_or_default(),
+            );
+        }
     }
 }

crates/codegen/src/top_level.rs

@@ -24,7 +24,21 @@ impl GetRust for GenericsDecl {
 impl GetRust for GenericDecl {
     fn get_rust(&self) -> String {
         match self {
-            GenericDecl::Lifetime(name) => format!("'{}", name.get_rust()),
+            GenericDecl::Lifetime(name, requirements) => {
+                format!("'{}", name.get_rust())
+                    + &(if requirements.len() != 0 {
+                        format!(
+                            ": {}",
+                            requirements
+                                .into_iter()
+                                .map(GetRust::get_rust)
+                                .collect::<Vec<_>>()
+                                .join("+")
+                        )
+                    } else {
+                        String::new()
+                    })
+            }
             GenericDecl::Type(name, requirements) => {
                 name.get_rust()
                     + &(if requirements.len() != 0 {
@@ -32,7 +46,7 @@ impl GetRust for GenericDecl {
                             ": {}",
                             requirements
                                 .into_iter()
-                                .map(TypeExpr::get_rust)
+                                .map(GetRust::get_rust)
                                 .collect::<Vec<_>>()
                                 .join("+")
                         )
@@ -191,6 +205,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()))
             }
@@ -294,6 +340,23 @@ impl GenRust for TopLevelKind {
                 constructor,
                 items,
             ),
+            Self::IncludeGlobal(incl) => {
+                cg.crates
+                    .entry(incl.0[0].clone())
+                    .or_insert(Vec::new())
+                    .push(crate::Include::Glob(incl.clone()));
+            }
+            Self::IncludeUse(vis, incl) => {
+                cg.crates
+                    .entry(incl.0[0].clone())
+                    .or_insert(Vec::new())
+                    .push(crate::Include::Use(vis.clone(), incl.clone()));
+            }
+            Self::IncludeLocal(path) => {
+                cg.add("include!(\"");
+                cg.add(&path.replace(".mist", ".rs"));
+                cg.add("\");");
+            }
         }
     }
 }

crates/mist-api/Cargo.toml

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

crates/mist-api/src/builder.mist

@@ -19,19 +19,19 @@ use mist_parser::rev_mapper;
 #[derive(Debug, Clone)]
 pub struct MistDiagnosticMessage
 {
-    pub String message,
+    pub String message;
-    pub PathBuf file_path,
+    pub PathBuf file_path;
-    pub String file_name,
+    pub String file_name;
-    pub usize line,
+    pub usize line;
-    pub usize column,
+    pub usize column;
 }
 
 #[derive(Debug, Clone)]
 pub enum MistDiagnostic
 {
-    Error(MistDiagnosticMessage),
+    Error(MistDiagnosticMessage);
-    Warning(MistDiagnosticMessage),
+    Warning(MistDiagnosticMessage);
-    Rust(CompilerMessage),
+    Rust(CompilerMessage);
 }
 
 pub bool build(Vec<String> mut args, PathBuf root)
@@ -58,28 +58,36 @@ pub bool build(Vec<String> mut args, PathBuf root)
                             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 rust_lookup = rev_mapper::RustMap(span.line_end - 1, span.column_start - 1);
-                        let mist_msg = MistDiagnosticMessage {
+                        match map.find(&rust_lookup) {
-                            message: format!("{}: {}",
+                            Some((_, rev_mapper::MistMap(line, column))) => {
-                                msg.message.message,
+                                let mist_msg = MistDiagnosticMessage {
-                                span.label.clone().unwrap_or_default()),
+                                    message: format!("{}: {}",
-                            file_name: if let Ok(mist_file) = mist_file {
+                                        msg.message.message,
-                                mist_file.to_string_lossy().to_string()
+                                        span.label.clone().unwrap_or_default()),
-                            } else {
+                                    file_name: if let Ok(mist_file) = mist_file {
-                                map.mist_path.to_string_lossy().to_string()
+                                        mist_file.to_string_lossy().to_string()
-                            },
+                                    } else {
-                            file_path: map.mist_path.clone(),
+                                        map.mist_path.to_string_lossy().to_string()
-                            line: line,
+                                    },
-                            column: column,
+                                    file_path: map.mist_path.clone(),
-                        };
+                                    line: line,
-                        match msg.message.level {
+                                    column: column,
-                            cargo_metadata::diagnostic::DiagnosticLevel::Error => {
+                                };
-                                diagnostics.push(MistDiagnostic::Error(mist_msg))
+                                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))
+                                    }
+                                    _ => {
+                                    }
+                                }
                             }
-                            cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
+                            None => {
-                                diagnostics.push(MistDiagnostic::Warning(mist_msg))
+                                diagnostics.push(MistDiagnostic::Rust(msg));
-                            }
+                                break;
-                            _ => {
                             }
                         }
                     }
@@ -110,8 +118,8 @@ pub void print_diagnostics(Vec<MistDiagnostic>& diagnostics)
                 let line = get_line(&mut files, &msg);
                 println!("\n{}:{}:{}\n \x1b[31mError\x1b[0m: {}\n\t{}",
                     msg.file_name,
-                    msg.line,
+                    msg.line + 1,
-                    msg.column,
+                    msg.column + 1,
                     msg.message,
                     line.unwrap_or_default(),)
             }
@@ -119,8 +127,8 @@ pub void print_diagnostics(Vec<MistDiagnostic>& diagnostics)
                 let line = get_line(&mut files, &msg);
                 println!("\n{}:{}:{}\n \x1b[33mWarning\x1b[0m: {}\n\t{}",
                     msg.file_name,
-                    msg.line,
+                    msg.line + 1,
-                    msg.column,
+                    msg.column + 1,
                     msg.message,
                     line.unwrap_or_default(),)
             }
@@ -135,5 +143,5 @@ pub Option<String> get_line(HashMap<PathBuf, Vec<String>> mut& files, MistDiagno
     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()
     });
-    lines.get(msg.line - 1).map((v) => v.trim().to_string())
+    lines.get(msg.line).map((v) => v.trim().to_string())
 }

crates/mist-api/src/modules.mist

@@ -76,7 +76,9 @@ 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 {
+        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

crates/mist-api/src/transpiler.mist

@@ -10,8 +10,6 @@ use std::process;
 
 use std::time;
 
-use std::env;
-
 use mist_parser::error;
 
 use crate::modules;
@@ -24,10 +22,10 @@ use serde::Deserialize;
 #[serde(default)]
 pub struct MistConfig
 {
-    pub PathBuf package,
+    pub PathBuf package;
-    pub Vec<PathBuf> packages,
+    pub Vec<PathBuf> packages;
-    pub Vec<PathBuf> include,
+    pub Vec<PathBuf> include;
-    pub mist_parser::MistFmtConfig fmt,
+    pub mist_parser::MistFmtConfig fmt;
 }
 
 impl MistConfig
@@ -79,6 +77,7 @@ pub void transpile(Path& root)
     let elapsed = start.elapsed();
     println!("\x1b[32m\nTranspile successful\x1b[0m in \x1b[34m{:.2?}\x1b[0m", elapsed);
     for incl in &config.include {
+        let incl = if incl.is_relative() { root.join(incl) } else { incl.clone() };
         if ends_with_star(&incl) {
             let sub_crates = incl.parent().expect("Failed to get parent");
             let entries = match fs::read_dir(sub_crates) {
@@ -97,7 +96,7 @@ pub void transpile(Path& root)
                 }
             }
         } else {
-            transpile(incl);
+            transpile(&incl);
         }
     }
 }
@@ -138,12 +137,37 @@ impl modules::Module
     }
     (bool, String) write_transpile(&self, String output, PathBuf& parent_dir, bool child_changed)
     {
-        if self.path.is_dir() {
+        if self.path.is_dir() || self.is_package() {
             let output_file = self.output_path(parent_dir, &None);
-            if output.len() == 0 {
+            let final_output = if self.is_package() {
-                return (true, String::new());
+                let source = match fs::read_to_string(&self.path) {
-            }
+                    Ok(s) => s,
-            let res = fs::write(&output_file, output);
+                    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(),
@@ -186,8 +210,8 @@ std::io::Result<bool> is_source_newer(Path& source, Path& output)
 
 pub enum TranspileError<'a>
 {
-    Parse(error::ParseError<'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)
@@ -224,13 +248,16 @@ pub void transpile_file(PathBuf& path, str& source, PathBuf output_file, str& mo
             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  {}",
             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  {}",

crates/parser/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-parser"
-version = "0.3.7-alpha.1"
+version = "0.4.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/mod.rs

@@ -41,13 +41,13 @@ pub enum TypeExpr {
     Path(Path, Option<Generics>),
     StaticFn(Vec<TypeExpr>, Option<Box<TypeExpr>>),
     Tuple(Vec<TypeExpr>),
-    Lifetime(Identifier),
     Void,
     Fn {
         kind: FnKind,
         return_type: Box<TypeExpr>,
         params: Vec<TypeExpr>,
     },
+    Array(Box<TypeExpr>, Option<isize>)
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -60,7 +60,7 @@ pub struct Spanned<T> {
 impl From<GenericDecl> for Generic {
     fn from(value: GenericDecl) -> Self {
         match value {
-            GenericDecl::Lifetime(life) => Generic::Lifetime(life),
+            GenericDecl::Lifetime(life, _) => Generic::Lifetime(life),
             GenericDecl::Type(ty, _) => Generic::Type(TypeExpr::Path(Path(vec![ty]), None)),
         }
     }

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>,
@@ -43,8 +44,10 @@ pub struct MatchItem(pub Vec<Pattern>, pub Expression);
 
 #[derive(Debug, Clone, Serialize)]
 pub struct VarDecl {
-    pub name: Pattern,
     pub type_: Option<TypeExpr>,
+    pub name: Pattern,
+    pub true_type: bool,
+    pub tuple_names: Vec<Pattern>,
 }
 
 #[derive(Debug, Clone, Serialize)]

crates/parser/src/ast/top_level.rs

@@ -28,8 +28,18 @@ pub struct TopLevel(pub Spanned<TopLevelKind>, pub Vec<Attribute>);
 pub enum TopLevelKind {
     ModAttribute,
     Import(Visibility, Path),
+    IncludeGlobal(Path),
+    IncludeUse(Visibility, Path),
+    IncludeLocal(String),
     DeclareModule(Visibility, Identifier),
     ImplDecl(ImplDecl),
+    StaticDecl(VarDeclStmt),
+    ConstDecl(VarDeclStmt),
+    TypeAlias {
+        name: Identifier,
+        generics: Option<GenericsDecl>,
+        ty: TypeExpr,
+    },
     TraitDecl {
         visibility: Visibility,
         name: Identifier,
@@ -72,8 +82,8 @@ pub struct GenericsDecl(pub Vec<GenericDecl>);
 
 #[derive(Debug, Clone, Serialize)]
 pub enum GenericDecl {
-    Lifetime(Identifier),
+    Lifetime(Identifier, Vec<Generic>),
-    Type(Identifier, Vec<TypeExpr>),
+    Type(Identifier, Vec<Generic>),
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -97,12 +107,13 @@ pub struct Override(pub Option<ExprPath>);
 #[derive(Debug, Clone, Serialize)]
 pub struct FunctionDecl {
     pub visibility: Visibility,
-    pub is_override: Option<Override>,
+    pub is_virtual: bool,
+    pub return_type: Option<TypeExpr>,
     pub name: Identifier,
     pub generics: GenericsDecl,
     pub self_param: Option<(bool, Option<Identifier>, bool)>,
     pub params: ParamList,
-    pub return_type: Option<TypeExpr>,
+    pub is_override: Option<Override>,
     pub body: Option<Block>,
 }
 

crates/parser/src/error.rs

@@ -24,6 +24,7 @@ pub enum ErrorCode {
     InvalidStatement,
     AstGenBug,
     Module,
+    NumberParse,
 }
 
 impl From<pest::error::Error<Rule>> for ParseError<'_> {

crates/parser/src/grammar.pest

@@ -24,6 +24,7 @@ keyword = {
   | "class"
   | "trait"
   | "impl"
+  | "use"
   | "pub"
   | "mut"
   | "let"
@@ -33,6 +34,9 @@ keyword = {
   | "loop"
   | "unsafe"
   | "override"
+  | "const"
+  | "type"
+  | "virtual"
 }
 
 identifier = @{
@@ -86,7 +90,7 @@ mutable    = { "mut" }
 // ======================================================
 // GENERICS
 // ======================================================
-generic_decl  = { lifetime | (identifier ~ (":" ~ generic ~ ("+" ~ generic)*)?) }
+generic_decl  = { (lifetime | identifier) ~ (":" ~ generic ~ ("+" ~ generic)*)? }
 generics_decl = { "<" ~ (generic_decl ~ ("," ~ generic_decl)*)? ~ ">" }
 
 generic  = { lifetime | type_expr }
@@ -121,9 +125,9 @@ fn_kind_mut     = { "FnMut" }
 fn_kind = _{
     fn_kind_fn
   | fn_kind_unsafe
-  | fn_kind_closure
   | fn_kind_once
   | fn_kind_mut
+  | fn_kind_closure
 }
 
 fn_type = {
@@ -138,8 +142,12 @@ void_type = {
     "void"
 }
 
+array_type = {
+    "[" ~ integer? ~ "]"
+}
+
 type_expr = {
-    (void_type | path_type | tuple_type | dyn_type) ~ (unsafe_ref_type | ref_type | fn_type)*
+    (void_type | path_type | tuple_type | dyn_type) ~ (unsafe_ref_type | ref_type | fn_type | array_type)*
 }
 
 lifetime = {
@@ -222,9 +230,12 @@ attributes = {
 // ======================================================
 // DECLARATION HELPERS
 // ======================================================
+as_kw = { "as" }
+
 var_decl = {
-    ("let" ~ pattern)
+    ("let" ~ pattern ~ ("," ~ pattern)*)
-  | type_expr ~ (!tuple_pattern ~ pattern)
+  | (type_expr ~ as_kw ~ (!tuple_pattern ~ pattern ~ ("," ~ pattern)+))
+  | (type_expr ~ (!tuple_pattern ~ pattern ~ ("," ~ pattern)*))
 }
 
 field = {
@@ -237,7 +248,7 @@ param = {
 }
 
 field_list = {
-    (field ~ ("," ~ field)* ~ ","?)?
+    (field ~ ";")*
 }
 
 param_list = {
@@ -248,6 +259,18 @@ param_list = {
 // IMPORTS / MODULES
 // ======================================================
 
+include_global = {
+    "#" ~ "include" ~ "<" ~ identifier ~ ("/" ~ identifier)* ~ ">"
+}
+
+include_use_global = {
+    visibility? ~ "#" ~ "use" ~ static_path ~ semicolon
+}
+
+include_local = {
+    "#" ~ "include" ~ string_lit
+}
+
 import = {
     visibility? ~ "use" ~ static_path ~ semicolon
 }
@@ -261,7 +284,7 @@ declare_module = {
 // ======================================================
 
 struct_decl = {
-    visibility? ~ "struct" ~ identifier ~ generics_decl? ~ "{" ~ field_list? ~ "}"
+    visibility? ~ "struct" ~ identifier ~ generics_decl? ~ "{" ~ field_list ~ "}"
 }
 
 // ======================================================
@@ -286,12 +309,8 @@ enum_field = _{
   | enum_named
 }
 
-enum_fields = _{
-    enum_field ~ ("," ~ enum_field)* ~ ","?
-}
-
 enum_decl = {
-    visibility? ~ "enum" ~ identifier ~ generics_decl? ~ "{" ~ enum_fields? ~ "}"
+    visibility? ~ "enum" ~ identifier ~ generics_decl? ~ "{" ~ (enum_field ~ ";")* ~ "}"
 }
 
 // ======================================================
@@ -355,19 +374,32 @@ trait_decl = {
 // FUNCTIONS
 // ======================================================
 
+virtual_kw = { "virtual" }
+
 override_kw = { "override" ~ ("(" ~ expr_path ~ ")")? }
 
 function_decl = {
-    visibility? ~ ("void" | type_expr) ~ identifier ~ generics_decl? ~ "(" ~ method_args ~ ")" ~ override_kw? ~ (block | semicolon)
+    visibility? ~ virtual_kw? ~ ("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 ~ (include_global | include_local | include_use_global | 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 +420,7 @@ statement_list = {
 
 statement = _{
     control_flow
+  | top_level
   | (expr ~ semicolon)
 }
 

crates/parser/src/parser/common/decl.rs

@@ -2,7 +2,7 @@ use crate::{
     Rule,
     ast::*,
     error::{AstError, collect_recovered},
-    parser::consume_rule,
+    parser::{consume_rule, listen_rule},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDeclStmt {
@@ -55,7 +55,9 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDecl {
                     type_: consume_rule(&mut inner, Rule::type_expr)
                         .map(TypeExpr::try_from)
                         .transpose()?,
+                    true_type: listen_rule(&mut inner, Rule::as_kw),
                     name: Pattern::try_from(inner.next().unwrap())?,
+                    tuple_names: collect_recovered(inner)?,
                 })
             }
 

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/common/types.rs

@@ -50,13 +50,31 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExpr {
                             };
                         }
 
+                        Rule::array_type => {
+                            ty = TypeExpr::Array(
+                                Box::new(ty),
+                                ref_inner
+                                    .next()
+                                    .map(|v| {
+                                        v.as_str().parse().map_err(|_| AstError {
+                                            span: v.as_span(),
+                                            error_code: crate::error::ErrorCode::NumberParse,
+                                            error_message: format!(
+                                                "Number exceeds isize limits: {}",
+                                                v.as_str()
+                                            ),
+                                        })
+                                    })
+                                    .transpose()?,
+                            )
+                        }
+
                         _ => AstError::bug_unimplemented(ref_pair)?,
                     }
                 }
 
                 Ok(ty)
             }
-            Rule::lifetime => Ok(TypeExpr::Lifetime(inner.next().unwrap().try_into()?)),
 
             Rule::void_type => Ok(TypeExpr::Void),
             Rule::tuple_type => Ok(TypeExpr::Tuple(collect_recovered(inner)?)),
@@ -113,6 +131,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for GenericDecl {
             if let Some(pair) = consume_rule(&mut inner, Rule::lifetime) {
                 Ok(GenericDecl::Lifetime(
                     pair.into_inner().next().unwrap().try_into()?,
+                    collect_recovered(inner)?,
                 ))
             } else {
                 Ok(GenericDecl::Type(

crates/parser/src/parser/items/function.rs

@@ -14,6 +14,8 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
         let mut inner = pair.into_inner();
             let visibility = Visibility::try_from(&mut inner)?;
 
+            let is_virtual = listen_rule(&mut inner, Rule::virtual_kw);
+
             let return_type = consume_rule(&mut inner, Rule::type_expr)
                 .map(TypeExpr::try_from)
                 .transpose()?;
@@ -45,12 +47,13 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
 
             Ok(Self {
                 visibility: visibility,
-                is_override: is_override,
+                is_virtual: is_virtual,
                 return_type: return_type,
                 name: name,
                 generics: generics,
                 self_param: self_param,
                 params: params,
+                is_override: is_override,
                 body: body,
             })
         })

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

@@ -54,11 +54,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TopLevelKind {
                     .transpose()
                     .map(|v| v.unwrap_or_default())?,
 
-                fields: inner
+                fields: collect_recovered(inner.next().unwrap().into_inner())?,
-                    .next()
-                    .map(|pair| collect_recovered(pair.into_inner()))
-                    .transpose()
-                    .map(|v| v.unwrap_or_default())?,
             }),
 
             Rule::class_decl => Ok(TopLevelKind::ClassDecl {
@@ -122,6 +118,36 @@ 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()?,
+            }),
+
+            Rule::include_global => Ok(TopLevelKind::IncludeGlobal(Path(collect_recovered(
+                &mut inner,
+            )?))),
+
+            Rule::include_use_global => Ok(TopLevelKind::IncludeUse(
+                Visibility::try_from(&mut inner)?,
+                Path::try_from(inner.next().unwrap())?,
+            )),
+
+            Rule::include_local => Ok(TopLevelKind::IncludeLocal(
+                inner
+                    .next()
+                    .unwrap()
+                    .into_inner()
+                    .next()
+                    .unwrap()
+                    .to_string(),
+            )),
+
             _ => AstError::bug_unimplemented(pair),
         }
     }

crates/parser/src/rev_mapper.rs

@@ -3,12 +3,12 @@ use std::{collections::HashSet, path::PathBuf};
 use serde::{Deserialize, Serialize};
 
 #[derive(
-    Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,
+    Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,
 )]
 pub struct MistMap(pub usize, pub usize);
 
 #[derive(
-    Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,
+    Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize,
 )]
 pub struct RustMap(pub usize, pub usize);
 

crates/parser/src/semantics.rs

@@ -46,10 +46,13 @@ pub fn check_class_semantics<'a>(top_level: &TopLevel) -> Result<(), Vec<Semanti
         if let Some(constructor) = constructor {
             let mut fields = fields
                 .iter()
-                .map(|field| Spanned {
+                .filter_map(|field| match field.item.init {
-                    item: field.item.decl.name.clone(),
+                    Some(_) => None,
-                    line: field.line,
+                    None => Some(Spanned {
-                    column: field.column,
+                        item: field.item.decl.name.clone(),
+                        line: field.line,
+                        column: field.column,
+                    }),
                 })
                 .collect::<Vec<_>>();
 
@@ -99,6 +102,28 @@ pub fn check_class_semantics<'a>(top_level: &TopLevel) -> Result<(), Vec<Semanti
         }
 
         Ok(())
+    } else if let TopLevelKind::FunctionDecl(decl) = &top_level.0.item {
+        if decl.is_virtual && decl.is_override.is_some() {
+            Err(vec![SemanticError {
+                line: top_level.0.line,
+                column: top_level.0.column,
+                error_message: "virtual and override are only used in classes".to_string(),
+            }])
+        } else if decl.is_virtual {
+            Err(vec![SemanticError {
+                line: top_level.0.line,
+                column: top_level.0.column,
+                error_message: "virtual is only used in classes".to_string(),
+            }])
+        } else if decl.is_override.is_some() {
+            Err(vec![SemanticError {
+                line: top_level.0.line,
+                column: top_level.0.column,
+                error_message: "override is only used in classes".to_string(),
+            }])
+        } else {
+            Ok(())
+        }
     } else {
         Ok(())
     }
@@ -129,6 +154,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

@@ -6,6 +6,13 @@ pub void test_let_basic()
     assert_eq!(x, 42);
 }
 
+pub void test_let_repeat()
+{
+    let x, y = (42, 67);
+    assert_eq!(x, 42);
+    assert_eq!(y, 67);
+}
+
 pub void test_let_typed()
 {
     i32 x = 42;
@@ -18,6 +25,29 @@ pub void test_let_typed()
     assert_eq!(f, 3.14);
 }
 
+pub void test_let_repeat_typed()
+{
+    i32 x, x1 = (42, 67);
+    assert_eq!(x, 42);
+    assert_eq!(x1, 67);
+
+    str& s, s1 = ("hello", "world");
+    assert_eq!(s, "hello");
+    assert_eq!(s1, "world");
+
+    bool b, b1 = (true, false);
+    assert_eq!(b, true);
+    assert_eq!(b1, false);
+
+    f64 f, f1 = (3.14, 5.5);
+    assert_eq!(f, 3.14);
+    assert_eq!(f1, 5.5);
+
+    (i32, f64) as a, b = (70, 1.4);
+    assert_eq!(a, 70);
+    assert_eq!(b, 1.4);
+}
+
 pub void test_let_mut()
 {
     let mut _x = 42;
@@ -76,10 +106,33 @@ pub void test_let_bool()
     assert_eq!(t, !f);
 }
 
+pub void test_let_decl_only()
+{
+    let x;
+    x = 42;
+    assert_eq!(x, 42);
+}
+
+pub void test_let_typed_decl_only()
+{
+    i32 x;
+    x = 100;
+    assert_eq!(x, 100);
+}
+
+pub void test_let_decl_mut_no_init()
+{
+    let mut x;
+    x = 5;
+    assert_eq!(x, 5);
+}
+
 pub void run_tests()
 {
     test_let_basic();
+    test_let_repeat();
     test_let_typed();
+    test_let_repeat_typed();
     test_let_mut();
     test_let_tuple_destructure();
     test_let_nested_tuple();
@@ -88,4 +141,7 @@ pub void run_tests()
     test_let_with_type_and_init();
     test_string_literal();
     test_let_bool();
+    test_let_decl_only();
+    test_let_typed_decl_only();
+    test_let_decl_mut_no_init();
 }

mist-test/src/common/expr_test.mist

@@ -155,6 +155,63 @@ pub void test_binary_assign()
     assert_eq!(x, 2);
 }
 
+pub void test_binary_assign_bit()
+{
+    let mut x = 10;
+    x &= 12;
+    assert_eq!(x, 8);
+    x |= 1;
+    assert_eq!(x, 9);
+    x ^= 3;
+    assert_eq!(x, 10);
+    let mut y = 8;
+    y <<= 2;
+    assert_eq!(y, 32);
+    y >>= 1;
+    assert_eq!(y, 16);
+}
+
+pub void test_empty_tuple()
+{
+    let t = ();
+    assert_eq!(t, ());
+}
+
+pub void test_empty_array()
+{
+    let arr = [0; 0];
+    assert_eq!(arr.len(), 0);
+}
+
+pub void test_range_inclusive()
+{
+    let mut sum = 0;
+    for i in 1 ..= 3 {
+        sum += i;
+    }
+    assert_eq!(sum, 6);
+}
+
+pub void test_closure_no_args()
+{
+    let f = () => 42;
+    assert_eq!(f(), 42);
+}
+
+pub void test_closure_with_typed_params()
+{
+    let add = (i32 a, i32 b) => a + b;
+    assert_eq!(add(3, 4), 7);
+}
+
+pub void test_mut_ref()
+{
+    let mut x = 42;
+    let r = &mut x;
+    *r = 100;
+    assert_eq!(x, 100);
+}
+
 pub void run_tests()
 {
     test_literals();
@@ -174,4 +231,11 @@ pub void run_tests()
     test_if_expr();
     test_range_expr();
     test_binary_assign();
+    test_binary_assign_bit();
+    test_empty_tuple();
+    test_empty_array();
+    test_range_inclusive();
+    test_closure_no_args();
+    test_closure_with_typed_params();
+    test_mut_ref();
 }

mist-test/src/common/statement_test.mist

@@ -160,6 +160,68 @@ pub void test_for_with_pattern_destructure()
     assert_eq!(keys, 3);
 }
 
+pub void test_c_for_loop()
+{
+    let mut sum = 0;
+    for (let mut i = 0; i < 4; i++) {
+        sum += i;
+    }
+    assert_eq!(sum, 6);
+}
+
+pub void test_unsafe_block()
+{
+    let mut x = 42;
+    unsafe {
+        let r = &mut x;
+        *r = 100;
+    }
+    assert_eq!(x, 100);
+}
+
+pub void test_match_parenthesized()
+{
+    let result;
+    match (2) {
+        1 => result = 10,
+        2 => result = 20,
+        _ => panic!(),
+    }
+    assert_eq!(result, 20);
+}
+
+pub void test_if_parenthesized()
+{
+    let mut x = 0;
+    if (true) {
+        x = 1;
+    }
+    assert_eq!(x, 1);
+}
+
+pub void test_while_parenthesized()
+{
+    let mut count = 0;
+    while (count < 3) {
+        count++;
+    }
+    assert_eq!(count, 3);
+}
+
+pub void test_loop_with_break_value()
+{
+    let mut x = 0;
+    let result;
+    loop {
+        if x >= 3 {
+            result = x;
+            break;
+        }
+        x++;
+    }
+    assert_eq!(result, 3);
+}
+
 pub void run_tests()
 {
     test_var_decl();
@@ -176,4 +238,10 @@ pub void run_tests()
     test_match_or_pattern();
     test_match_default();
     test_for_with_pattern_destructure();
+    test_c_for_loop();
+    test_unsafe_block();
+    test_match_parenthesized();
+    test_if_parenthesized();
+    test_while_parenthesized();
+    test_loop_with_break_value();
 }

mist-test/src/common/types_test.mist

@@ -52,6 +52,30 @@ pub void test_fn_return_type() {
     assert_eq!(add(3, 4), 7);
 }
 
+pub void test_generic_type() {
+    Option<i32> x = Option::Some(42);
+    assert_eq!(x.is_some(), true);
+}
+
+type MyInt = i32;
+
+pub void test_type_alias() {
+    MyInt x = 42;
+    assert_eq!(x, 42);
+}
+
+const i32 MY_CONST = 100;
+
+pub void test_const_decl() {
+    assert_eq!(MY_CONST, 100);
+}
+
+static i32 my_static = 200;
+
+pub void test_static_decl() {
+    assert_eq!(my_static, 200);
+}
+
 pub void run_tests() {
     test_integer_type();
     test_float_type();
@@ -62,4 +86,8 @@ pub void run_tests() {
     test_mut_ref_type();
     test_void_type();
     test_fn_return_type();
+    test_generic_type();
+    test_type_alias();
+    test_const_decl();
+    test_static_decl();
 }

mist-test/src/items/attribute_test.mist

@@ -3,7 +3,7 @@ pub module attribute_test;
 #[derive(Debug)]
 pub struct Debuggable
 {
-    i32 value,
+    i32 value;
 }
 
 pub void test_derive_attribute()
@@ -22,8 +22,21 @@ pub void test_allow_attribute()
     assert_eq!(x, 42);
 }
 
+#[allow(dead_code)]
+pub struct Tagged
+{
+    i32 id;
+}
+
+pub void test_attribute_with_args()
+{
+    Tagged t = Tagged { id: 1 };
+    assert_eq!(t.id, 1);
+}
+
 pub void run_tests()
 {
     test_derive_attribute();
     test_allow_attribute();
+    test_attribute_with_args();
 }

mist-test/src/items/class_test.mist

@@ -1,5 +1,9 @@
 pub module class_test;
 
+pub enum AnimalType {
+    Mammal;
+}
+
 pub class Animal
 {
     pub String name;
@@ -9,7 +13,11 @@ pub class Animal
         self.name = "Rex".to_string();
     }
 
-    pub String speak(&self)
+    pub virtual AnimalType get_animal_type(&self) {
+        panic!()
+    }
+
+    pub virtual String speak(&self)
     {
         "Unknown".to_string()
     }
@@ -31,6 +39,11 @@ pub class Mammal : Animal
         super = Super::new();
     }
 
+    // override without a target assumes current super
+    pub AnimalType get_animal_type(&self) override {
+        AnimalType::Mammal
+    }
+
     pub void args_test(&self, i32 x, str& y)
     {
         assert_eq!(x, 10);
@@ -59,10 +72,74 @@ pub class Dog : Mammal
     }
 }
 
+pub class Counter
+{
+    pub i32 count;
+
+    constructor()
+    {
+        self.count = 42;
+    }
+
+    i32 get_count(&self)
+    {
+        self.count
+    }
+
+    pub i32 static_fn()
+    {
+        99
+    }
+}
+
+pub void test_class_no_inheritance()
+{
+    Counter c = Counter::new();
+    assert_eq!(c.get_count(), 42);
+}
+
+pub class WithDefault
+{
+    pub String name = "default".to_string();
+    pub i32 value = 42;
+
+    constructor()
+    {
+    }
+
+    pub String get_name(&self)
+    {
+        self.name.clone()
+    }
+}
+
+pub void test_class_field_default()
+{
+    WithDefault w = WithDefault::new();
+    assert_eq!(w.get_name(), "default");
+    assert_eq!(w.value, 42);
+}
+
+pub class EmptyClass
+{
+    constructor()
+    {
+    }
+}
+
+pub void test_class_empty()
+{
+    EmptyClass e = EmptyClass::new();
+}
+
 pub void run_tests()
 {
     let dawg = Dog::new();
     dawg.args_test(10, "hello");
     dawg.test_speak();
+    dawg.get_animal_type();
     assert_eq!(format!("{dawg}"), "🐾 Rex");
+    test_class_no_inheritance();
+    test_class_field_default();
+    test_class_empty();
 }

mist-test/src/items/enum_test.mist

@@ -2,8 +2,8 @@ pub module enum_test;
 
 enum OptionInt
 {
-    None,
+    None;
-    Some(i32),
+    Some(i32);
 }
 
 pub void test_enum_named()
@@ -34,8 +34,13 @@ pub void test_enum_tuple()
 
 enum Shape
 {
-    Circle {i32 radius},
+    Circle {
-    Rect {i32 w, i32 h},
+        i32 radius;
+    };
+    Rect {
+        i32 w;
+        i32 h;
+    };
 }
 
 pub void test_enum_struct()
@@ -67,9 +72,9 @@ pub void test_enum_struct()
 
 enum Color
 {
-    Red,
+    Red;
-    Green,
+    Green;
-    Blue,
+    Blue;
 }
 
 pub void test_enum_eq()
@@ -85,10 +90,40 @@ pub void test_enum_eq()
     }
 }
 
+enum Option<T>
+{
+    None;
+    Some(T);
+}
+
+pub void test_generic_enum()
+{
+    Option<i32> x = Option::Some(42);
+    match x {
+        Option::Some(v) => {
+            assert_eq!(v, 42);
+        }
+        _ => {
+            assert_eq!(0, 1);
+        }
+    }
+
+    Option<bool> y = Option::None;
+    match y {
+        Option::None => {
+            assert_eq!(1, 1);
+        }
+        _ => {
+            assert_eq!(0, 1);
+        }
+    }
+}
+
 pub void run_tests()
 {
     test_enum_named();
     test_enum_tuple();
     test_enum_struct();
     test_enum_eq();
+    test_generic_enum();
 }

mist-test/src/items/function_test.mist

@@ -69,6 +69,17 @@ pub void test_recursive_fn()
     assert_eq!(factorial(5), 120);
 }
 
+T identity<T>(T x)
+{
+    x
+}
+
+pub void test_fn_generic()
+{
+    assert_eq!(identity(42), 42);
+    assert_eq!(identity("hello"), "hello");
+}
+
 pub void run_tests()
 {
     test_basic_function();
@@ -79,4 +90,5 @@ pub void run_tests()
     test_method_call();
     test_nested_fn_calls();
     test_recursive_fn();
+    test_fn_generic();
 }

mist-test/src/items/impl_test.mist

@@ -2,8 +2,8 @@ pub module impl_test;
 
 struct Vector2
 {
-    i32 x,
+    i32 x;
-    i32 y,
+    i32 y;
 }
 
 impl Vector2
@@ -72,9 +72,29 @@ pub void test_multiple_impls()
     assert_eq!(c.y, 6);
 }
 
+struct Wrapper<T>
+{
+    T value;
+}
+
+impl<T: Copy> Wrapper<T>
+{
+    pub T get(&self)
+    {
+        self.value
+    }
+}
+
+pub void test_impl_generic()
+{
+    Wrapper<i32> w = Wrapper { value: 42 };
+    assert_eq!(w.get(), 42);
+}
+
 pub void run_tests()
 {
     test_inherent_impl();
     test_trait_impl_block();
     test_multiple_impls();
+    test_impl_generic();
 }

mist-test/src/items/struct_test.mist

@@ -2,8 +2,8 @@ pub module struct_test;
 
 struct Point
 {
-    i32 x,
+    i32 x;
-    i32 y,
+    i32 y;
 }
 
 pub void test_struct_create_access()
@@ -39,8 +39,8 @@ pub void test_struct_destructure()
 
 struct Line
 {
-    Point start,
+    Point start;
-    Point end,
+    Point end;
 }
 
 pub void test_struct_nested()
@@ -59,10 +59,55 @@ pub void test_struct_nested()
     assert_eq!(l.end.y, 10);
 }
 
+struct Empty {}
+
+pub void test_empty_struct()
+{
+    let e = Empty {};
+}
+
+struct Pair<T>
+{
+    T first;
+    T second;
+}
+
+pub void test_generic_struct()
+{
+    Pair<i32> p = Pair<i32> { first: 1, second: 2 };
+    assert_eq!(p.first, 1);
+    assert_eq!(p.second, 2);
+}
+
+pub void test_struct_partial_destructure()
+{
+    let p = Point {
+        x: 10,
+        y: 20,
+    };
+    let Point {x, ..} = p;
+    assert_eq!(x, 10);
+}
+
+pub void test_struct_destructure_rename()
+{
+    let p = Point {
+        x: 5,
+        y: 15,
+    };
+    let Point {x: a, y: b} = p;
+    assert_eq!(a, 5);
+    assert_eq!(b, 15);
+}
+
 pub void run_tests()
 {
     test_struct_create_access();
     test_struct_mut_field();
     test_struct_destructure();
     test_struct_nested();
+    test_empty_struct();
+    test_generic_struct();
+    test_struct_partial_destructure();
+    test_struct_destructure_rename();
 }

mist-test/src/items/trait_test.mist

@@ -12,7 +12,7 @@ trait Greet : Speak
 
 struct Dog
 {
-    String name,
+    String name;
 }
 
 impl Speak for Dog

src/main.mist

@@ -10,15 +10,17 @@ use mist_api::transpiler;
 
 void main()
 {
-    Vec<String> args = env::args().collect();
+    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" => {
+        "run" | "build" | "check" | "test" | "bench" | "doc" | "fix" | "clippy" | "r" | "b" | "c" => {
-            let root = env::current_dir().expect("Unable to find project root");
+            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");
@@ -26,13 +28,37 @@ void main()
                 println!("\x1b[31m\nBuild failed\x1b[0m");
             }
         }
-        "transpile" | "t" => {
+        "publish" => {
-            let root = env::current_dir().expect("Unable to find project root");
+            let mut root = env::current_dir().expect("Unable to find project root");
+            modify_args(&mut args, &mut root);
             transpiler::transpile(&root);
+
+            let status = std::process::Command::new("cargo")
+                .args(args)
+                .status()
+                .expect("Failed to run cargo");
+
+            if status.success() {
+                println!("\x1b[32m\nPublished successfully\x1b[0m");
+            } else {
+                println!("\x1b[31m\nFailed to publish\x1b[0m");
+            }
+        }
+        "transpile" | "t" => {
+            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"));
         }
@@ -47,44 +73,123 @@ void main()
     }
 }
 
+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 print_usage()
 {
     println!("Mist - the mist compiler\n");
-    println!("󰖟 View our documentation! \x1b[35mhttps://mist.selimaj.dev\x1b[0m");
+    println!("󰖟 View our documentation! \x1b[95mhttps://mist.selimaj.dev\x1b[0m");
-    println!(" Follow us on github!    \x1b[35mhttps://github.com/mist-go\x1b[0m\n");
+    println!(" Follow us on github!    \x1b[95mhttps://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[96m mist run\x1b[0m,\x1b[96m r\x1b[0m            run the project\n");
-    println!(" \x1b[36m mist build\x1b[0m,\x1b[36m b\x1b[0m          build the project in the current directory\n");
+    println!(" \x1b[96m mist build\x1b[0m,\x1b[96m b\x1b[0m          build the project\n");
-    println!(" \x1b[36m mist transpile\x1b[0m,\x1b[36m t\x1b[0m      transpile the project in the current directory\n");
+    println!(" \x1b[96m mist test\x1b[0m              test the project\n");
-    println!(" \x1b[36m mist check\x1b[0m,\x1b[36m c\x1b[0m          check the project in the current directory\n");
+    println!(" \x1b[96m mist publish\x1b[0m           publish the project\n");
-    println!(" \x1b[36m mist init\x1b[0m              initialize a project in the current folder\n");
+    println!(" \x1b[96m mist bench\x1b[0m             benchmark the project\n");
-    println!(" \x1b[36m mist version \x1b[0m          print the compiler version\n");
+    println!(" \x1b[96m mist doc\x1b[0m               build documentation\n");
-    println!(" \x1b[36m mist help\x1b[0m              print this message\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 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 {
+        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");
-    str& inject = if is_lib {
+    toml::Value parsed = toml::from_str(&toml_content).expect("Failed to parse Cargo.toml");
-        "\n[lib]\nname = \"my_lib\"\npath = \".mist/src/lib.rs\"\n"
+    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 {
-        "\n[[bin]]\nname = \"my_bin\"\npath = \".mist/src/main.rs\"\n"
+        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");
+    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");
+}
+
+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");
+        }
+    }
 }