Bump version

Mist fmt style

.gitignore

@@ -29,3 +29,6 @@ target
 **/build
 
 .mist/
+
+analyzer.bat
+analyzer.sh

Cargo.lock

@@ -45,6 +45,12 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "bytecount"
+version = "0.6.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
+
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -122,7 +128,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
  "cfg-if",
- "hashbrown",
+ "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -136,7 +142,7 @@ checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
 dependencies = [
  "cfg-if",
  "crossbeam-utils",
- "hashbrown",
+ "hashbrown 0.14.5",
  "lock_api",
  "once_cell",
  "parking_lot_core",
@@ -163,6 +169,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
 [[package]]
 name = "errno"
 version = "0.3.14"
@@ -274,6 +286,18 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
+[[package]]
+name = "hashbrown"
+version = "0.17.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed5909b6e89a2db4456e54cd5f673791d7eca6732202bbf2a9cc504fe2f9b84a"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "httparse"
 version = "1.10.1"
@@ -383,6 +407,16 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "indexmap"
+version = "2.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.17.1",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -442,40 +476,45 @@ dependencies = [
 
 [[package]]
 name = "mist-analyzer"
-version = "0.1.7-alpha.1"
+version = "0.3.7-alpha.0"
 dependencies = [
  "cargo_metadata",
  "dashmap 6.1.0",
+ "heck",
  "mist-codegen",
  "mist-parser",
+ "pest",
  "ropey",
  "serde",
  "serde_json",
  "tokio",
+ "toml",
  "tower-lsp",
 ]
 
 [[package]]
 name = "mist-api"
-version = "0.1.7-alpha.1"
+version = "0.3.7-alpha.0"
 dependencies = [
  "cargo_metadata",
  "mist-codegen",
  "mist-parser",
  "serde",
  "serde_json",
+ "toml",
 ]
 
 [[package]]
 name = "mist-codegen"
-version = "0.1.7-alpha.0"
+version = "0.3.7-alpha.0"
 dependencies = [
+ "bytecount",
  "mist-parser",
 ]
 
 [[package]]
 name = "mist-lang"
-version = "0.1.7-alpha.1"
+version = "0.3.7-alpha.0"
 dependencies = [
  "mist-analyzer",
  "mist-api",
@@ -483,7 +522,7 @@ dependencies = [
 
 [[package]]
 name = "mist-parser"
-version = "0.1.7-alpha.0"
+version = "0.3.7-alpha.0"
 dependencies = [
  "pest",
  "pest_derive",
@@ -711,6 +750,15 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "sha2"
 version = "0.10.9"
@@ -859,6 +907,45 @@ dependencies = [
  "tokio",
 ]
 
+[[package]]
+name = "toml"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
 [[package]]
 name = "tower"
 version = "0.4.13"
@@ -1014,6 +1101,12 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "winnow"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
+
 [[package]]
 name = "writeable"
 version = "0.6.3"

Cargo.toml

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

Mist.toml

@@ -1 +1,2 @@
 package = "main.mist"
+packages = []

README.md

@@ -1,4 +1,4 @@
-# Mist Language: <br/> A C++ inspired langauge in the Rust ecosystem
+# Mist - A Pragmatic Systems Language built on Rust
 
 <!--
 Originally this readme was part of the Carbon Language project, licensed with Apache-2.0
@@ -9,7 +9,7 @@ Originally this readme was part of the Carbon Language project, licensed with Ap
 </p>
 
 
-<img src="code.png" align="right" width="575" alt="">
+<img src="code.png" align="right" width="450" alt="">
 
 <!--
 Don't let the text wrap too narrowly to the left of the above image.
@@ -19,7 +19,7 @@ The `div` reduces the vertical height. The `picture` prevents autolinking.
 
 **Fast and works with Rust**
 
-- All of your favourite Rust libraries work with Mist
+- All of your favorite Rust libraries work with Mist
 - Compiles directly into efficient Rust code
 - Zero-cost abstractions, no runtime overhead
 
@@ -29,6 +29,6 @@ The `div` reduces the vertical height. The `picture` prevents autolinking.
 - Designed for fast, readable systems code
 
 **Class and type system**
-- class is syntactic sugar for a Rust struct
-- `struct B extends A` provides inheritance-style syntax over struct composition
+- class is syntactic sugar for a Rust struct with V Tables
+- `class B : A` provides inheritance-style syntax over struct composition
 - Classes and structs compile into the same underlying Rust type system model

analyzer.bat

@@ -1,9 +0,0 @@
-@echo off
-
-cd D:\projects\mist\mist
-
-mist build >nul 2>&1
-
-cd D:\projects\mist\mist-lsp-test
-
-D:\projects\mist\mist\target\debug\mist-analyzer.exe

crates/analyzer/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-analyzer"
-version = "0.1.7-alpha.1"
+version = "0.3.7-alpha.0"
 edition = "2024"
 description = "The Mist programming language Analyzer LSP"
 license = "Apache-2.0"
@@ -11,6 +11,7 @@ categories = ["compilers"]
 [dependencies]
 mist-parser = { workspace = true }
 mist-codegen = { workspace = true }
+pest = "2.8.6"
 
 dashmap = "6.1.0"
 tokio = { version = "1.52.3", features = ["full", "macros", "rt", "rt-multi-thread"] }
@@ -20,3 +21,5 @@ cargo_metadata = "0.23.1"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 ropey = "1"
+heck = "0.5.0"
+toml = "1.1.2"

crates/analyzer/src/builder.rs

@@ -1,139 +0,0 @@
-use std::{
-    collections::HashMap,
-    env, fs,
-    path::{MAIN_SEPARATOR, PathBuf},
-    process::{Command, Stdio},
-};
-
-use cargo_metadata::{CompilerMessage, Message};
-use mist_parser::rev_mapper::{RustMap, find_mapping, get_mapping};
-
-#[derive(Debug, Clone)]
-pub struct MistDiagnosticMessage {
-    pub message: String,
-    pub file_path: PathBuf,
-    pub file_name: String,
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Debug, Clone)]
-pub enum MistDiagnostic {
-    Error(MistDiagnosticMessage),
-    Warning(MistDiagnosticMessage),
-    Rust(CompilerMessage),
-}
-
-pub fn build(mut args: Vec<String>, root: PathBuf) -> Vec<MistDiagnostic> {
-    args.insert(1, "--message-format=json".to_string());
-
-    let is_root = root == env::current_dir().expect("Failed getting env");
-
-    let mut command = Command::new("cargo")
-        .args(args)
-        .stdout(Stdio::piped())
-        .spawn()
-        .expect("Failed to run cargo");
-
-    let mut reader = std::io::BufReader::new(command.stdout.take().expect("Failed to get reader"));
-
-    let mut diagnostics = Vec::new();
-
-    let mut mapping = HashMap::new();
-
-    let mist_src = format!(".mist{MAIN_SEPARATOR}lsp");
-
-    for message in cargo_metadata::Message::parse_stream(&mut reader) {
-        match message {
-            Ok(Message::CompilerMessage(msg)) => {
-                for span in &msg.message.spans {
-                    if span.is_primary {
-                        let rust_path = root.join(&span.file_name);
-
-                        let mist_file = span
-                            .file_name
-                            .replacen(&mist_src, "src", 1)
-                            .trim_end_matches(".rs")
-                            .to_string()
-                            + ".mist";
-
-                        let mist_path = root.join(&mist_file);
-
-                        if !fs::exists(&mist_path).expect("Unable to check if mist file exists") {
-                            diagnostics.push(MistDiagnostic::Rust(msg));
-                            break;
-                        }
-
-                        let map = mapping.entry(rust_path.clone()).or_insert_with(|| {
-                            get_mapping(
-                                &fs::read_to_string(rust_path)
-                                    .expect("Failed to read file for mapping"),
-                            )
-                        });
-
-                        let mist_span =
-                            find_mapping(&map, &RustMap(span.line_end, span.column_start))
-                                .expect("Unable to find mapping");
-
-                        let mist_msg = MistDiagnosticMessage {
-                            message: format!(
-                                "{}: {}",
-                                msg.message.message,
-                                span.label.clone().unwrap_or_default()
-                            ),
-                            file_name: if is_root {
-                                mist_file
-                            } else {
-                                mist_path.to_string_lossy().to_string()
-                            },
-                            file_path: mist_path,
-                            line: mist_span.1.0,
-                            column: mist_span.1.1,
-                        };
-
-                        match msg.message.level {
-                            cargo_metadata::diagnostic::DiagnosticLevel::Error => {
-                                diagnostics.push(MistDiagnostic::Error(mist_msg))
-                            }
-
-                            cargo_metadata::diagnostic::DiagnosticLevel::Warning => {
-                                diagnostics.push(MistDiagnostic::Warning(mist_msg))
-                            }
-
-                            _ => {}
-                        }
-                    }
-                }
-            }
-
-            Ok(Message::BuildFinished(_)) => {
-                command.wait().unwrap();
-
-                return diagnostics;
-            }
-
-            Ok(Message::TextLine(text)) => println!("{text}"),
-            _ => {}
-        }
-    }
-
-    diagnostics
-}
-
-pub fn get_line(
-    files: &mut HashMap<PathBuf, Vec<String>>,
-    msg: &MistDiagnosticMessage,
-) -> Option<String> {
-    let src_path = msg.file_path.clone();
-
-    let lines = files.entry(src_path.clone()).or_insert_with(|| {
-        fs::read_to_string(src_path)
-            .expect("Unable to read mist file")
-            .lines()
-            .into_iter()
-            .map(String::from)
-            .collect()
-    });
-
-    lines.get(msg.line - 1).map(|v| v.trim().to_string())
-}

crates/analyzer/src/rust_analyzer.rs

@@ -35,11 +35,9 @@ type PendingMap = Arc<Mutex<HashMap<usize, oneshot::Sender<Result<Value, String>
 
 #[derive(Debug)]
 pub struct RustAnalyzer {
-    // Wrapped in a Mutex to support safe concurrent sharing if the design expands
     stdin: Arc<Mutex<tokio::process::ChildStdin>>,
     pending: PendingMap,
     id: usize,
-    // Keep child handler to explicitly manage child process lifecycle and prevent zombie processes
     _child: tokio::process::Child,
 }
 
@@ -59,23 +57,32 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
 ) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
     let mut line = String::new();
     let mut content_length = 0;
+    let mut eof = false;
 
-    // Guard against infinite header reading attacks/bugs (Max 100 headers)
     for _ in 0..100 {
         line.clear();
         let bytes_read = reader.read_line(&mut line).await?;
-        if bytes_read == 0 || line == "\r\n" || line.is_empty() {
+        if bytes_read == 0 {
+            eof = true;
+            break;
+        }
+        if line.trim().is_empty() {
             break;
         }
         if line.to_ascii_lowercase().starts_with("content-length:") {
             if let Some(val_str) = line.split(':').nth(1) {
-                content_length = val_str.trim().parse::<usize>()?;
+                let trimmed = val_str.trim();
+                if !trimmed.is_empty() {
+                    content_length = trimmed.parse::<usize>()?;
+                }
             }
         }
     }
 
-    // Explode early if payload size violates strict guard rails to prevent memory-exhaustion (OOM)
     if content_length == 0 {
+        if eof {
+            return Err("LSP stream closed (EOF)".into());
+        }
         return Err("Missing, invalid, or zero Content-Length header".into());
     }
     if content_length > MAX_CONTENT_LENGTH {
@@ -86,7 +93,6 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
         .into());
     }
 
-    // Explicitly secure pre-allocation limit
     let mut buffer = vec![0u8; content_length];
     reader.read_exact(&mut buffer).await?;
 
@@ -94,11 +100,14 @@ async fn read_lsp_message<R: AsyncBufReadExt + Unpin>(
 }
 
 impl RustAnalyzer {
-    pub fn new() -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
-        let mut child = tokio::process::Command::new("rust-analyzer")
+    pub fn new(
+        notification_tx: tokio::sync::mpsc::UnboundedSender<Value>,
+    ) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
+        let mut child = tokio::process::Command::new("rustup")
+            .args(["run", "stable", "rust-analyzer"])
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
-            .stderr(Stdio::null())
+            .stderr(Stdio::piped())
             .spawn()?;
 
         let stdin = child
@@ -109,38 +118,72 @@ impl RustAnalyzer {
             .stdout
             .take()
             .ok_or("Failed to open child stdout pipe")?;
+        let stderr = child
+            .stderr
+            .take()
+            .ok_or("Failed to open child stderr pipe")?;
+
+        tokio::spawn(async move {
+            let mut stderr = stderr;
+            let mut buf = vec![0u8; 4096];
+            loop {
+                match stderr.read(&mut buf).await {
+                    Ok(0) => break,
+                    Ok(n) => {
+                        eprintln!(
+                            "[ra-stderr] {}",
+                            String::from_utf8_lossy(&buf[..n]).trim_end()
+                        );
+                    }
+                    Err(e) => {
+                        eprintln!("[ra-stderr] read error: {e}");
+                        break;
+                    }
+                }
+            }
+            eprintln!("[ra-stderr] stream closed");
+        });
 
         let pending: PendingMap = Arc::new(Mutex::new(HashMap::new()));
         let pending_clone = pending.clone();
 
-        // Background supervisor task loop
         tokio::spawn(async move {
             let mut stdout = BufReader::new(stdout);
+            eprintln!("[ra-reader] started");
 
             loop {
                 let raw = match read_lsp_message(&mut stdout).await {
                     Ok(v) => v,
                     Err(err) => {
-                        eprintln!("LSP fatal stream read failure: {err}");
-                        // CRITICAL: Notify all pending channels that the bridge broke down
+                        eprintln!("LSP stream error: {err}");
+                        // Drain pending requests so they don't hang forever.
                         let mut lock = pending_clone.lock().await;
                         for (_, tx) in lock.drain() {
-                            let _ = tx.send(Err(format!("LSP reader task dropped: {}", err)));
+                            let _ = tx.send(Err(format!("LSP reader error: {}", err)));
                         }
+                        // EOF means the child process exited — stop the reader.
+                        // Other errors (malformed frames) get a brief backoff then retry.
+                        if err.to_string().contains("LSP stream closed (EOF)") {
+                            eprintln!("LSP reader task: EOF detected, stopping reader");
                             break;
                         }
+                        tokio::time::sleep(Duration::from_millis(50)).await;
+                        continue;
+                    }
                 };
 
                 let value: Value = match serde_json::from_str(&raw) {
                     Ok(v) => v,
                     Err(err) => {
                         eprintln!("Corrupted JSON received: {err}");
-                        continue; // Keep the connection running despite malformed frame
+                        continue;
                     }
                 };
 
-                // Filter server notification frames
-                if value.get("method").is_some() && value.get("id").is_none() {
+                let is_notification = value.get("method").is_some() && value.get("id").is_none();
+
+                if is_notification {
+                    let _ = notification_tx.send(value);
                     continue;
                 }
 
@@ -181,7 +224,6 @@ impl RustAnalyzer {
 
         let (tx, rx) = oneshot::channel();
 
-        // Scope the lock allocation tightly
         {
             self.pending.lock().await.insert(id, tx);
         }
@@ -193,19 +235,15 @@ impl RustAnalyzer {
             "params": params,
         });
 
-        // Acquire lock on writing stream to ensure thread safety
         let mut stdin_lock = self.stdin.lock().await;
 
         if let Err(err) = send_lsp_message(&mut *stdin_lock, &payload).await {
-            // Rollback the pending map operation to avoid internal memory memory-leaks if serialization/IO errors trigger
             self.pending.lock().await.remove(&id);
             return Err(Box::new(err));
         }
 
-        // Explicit drop of write lock early so other operations can pipe messages synchronously
         drop(stdin_lock);
 
-        // Enforce an absolute time constraint limit to break free from hanging processes
         let response_payload = match timeout(REQUEST_TIMEOUT, rx).await {
             Ok(Ok(Ok(value))) => value,
             Ok(Ok(Err(task_err))) => return Err(task_err.into()),
@@ -215,7 +253,6 @@ impl RustAnalyzer {
                 );
             }
             Err(_timeout_elapsed) => {
-                // Clear state tracking entries dynamically upon expiration failure
                 self.pending.lock().await.remove(&id);
                 return Err(
                     format!("Request ID {} timed out after {:?}", id, REQUEST_TIMEOUT).into(),
@@ -290,8 +327,65 @@ impl RustAnalyzer {
     }
 
     pub async fn initialized(&mut self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
-        self.notify(Initialized::METHOD, InitializedParams {})
+        self.notify(<Initialized as Notification>::METHOD, InitializedParams {})
             .await?;
         Ok(())
     }
 }
+
+impl RustAnalyzer {
+    pub async fn did_open(
+        &mut self,
+        uri: Url,
+        text: &str,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        self.notify(
+            "textDocument/didOpen",
+            json!({
+                "textDocument": {
+                    "uri": uri,
+                    "languageId": "rust",
+                    "version": 1,
+                    "text": text,
+                }
+            }),
+        )
+        .await
+    }
+
+    pub async fn did_change(
+        &mut self,
+        uri: Url,
+        text: &str,
+        version: i32,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        self.notify(
+            "textDocument/didChange",
+            json!({
+                "textDocument": {
+                    "uri": uri,
+                    "version": version,
+                },
+                "contentChanges": [{
+                    "text": text,
+                }],
+            }),
+        )
+        .await
+    }
+
+    pub async fn did_close(
+        &mut self,
+        uri: Url,
+    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
+        self.notify(
+            "textDocument/didClose",
+            json!({
+                "textDocument": {
+                    "uri": uri,
+                }
+            }),
+        )
+        .await
+    }
+}

crates/analyzer/src/transpiler.rs

@@ -1,160 +1,96 @@
-use std::{
-    fs,
-    path::{Path, PathBuf},
-};
+use std::path::{Path, PathBuf};
 
-use mist_parser::{ast::TopLevel, error::ParseError};
+use mist_codegen::RustCodegen;
+use mist_codegen::fmt::MistCodegen;
+use mist_parser::rev_mapper::Mapping;
+use mist_parser::{MistFmtConfig, parse};
 
-pub fn build(root: &PathBuf) {
-    let src_dir = root.join("src");
-    let out_dir = root.join(".mist/src");
-
-    if let Err(e) = build_dir(root, &src_dir, &src_dir, &out_dir) {
-        eprintln!("Warning: Build directory run aborted safely: {e}");
-    }
+pub struct TranspiledFile {
+    pub mist_path: PathBuf,
+    pub rust_path: PathBuf,
+    pub rust_content: String,
+    pub mapping: Mapping,
 }
 
-fn build_dir(
-    root: &Path,
-    base_src: &Path,
-    current_dir: &Path,
-    out_dir: &Path,
-) -> Result<(), String> {
-    let entries = fs::read_dir(current_dir)
-        .map_err(|e| format!("failed to read directory {}: {}", current_dir.display(), e))?;
-
-    for entry in entries {
-        let entry = match entry {
-            Ok(entry) => entry,
-            Err(e) => {
-                eprintln!("Warning: Skipping invalid directory entry: {e}");
-                continue; // Skip corrupted entry instead of crashing
-            }
-        };
-
-        let path = entry.path();
-
-        // Recurse into nested directories
-        if path.is_dir() {
-            if let Err(e) = build_dir(root, base_src, &path, out_dir) {
-                eprintln!("Warning: Nested build directory failed: {e}");
-            }
-            continue;
+#[derive(Debug)]
+pub enum TranspileError<'a> {
+    Parse(mist_parser::error::ParseError<'a>),
+    Semantic(Vec<mist_parser::semantics::SemanticError>),
 }
 
-        // Safe prefix stripping fallback
-        let relative = match path.strip_prefix(base_src) {
-            Ok(p) => p,
-            Err(_) => {
-                eprintln!(
-                    "Warning: Path {} is outside base source directory",
-                    path.display()
-                );
-                continue;
-            }
-        };
-
-        // Handle non-mist files with a cache check
-        if path.extension().and_then(|e| e.to_str()) != Some("mist") {
-            let dest_path = out_dir.join(relative);
-
-            // Create parent directories for static assets if needed
-            if let Some(parent) = dest_path.parent() {
-                let _ = fs::create_dir_all(parent);
+pub fn transpile_mist<'a>(
+    mist_path: &Path,
+    source: &'a str,
+    extra_mod_decl: &str,
+) -> Result<TranspiledFile, TranspileError<'a>> {
+    let mut rust_path = crate::from_mist_to_rust(mist_path.to_path_buf());
+    // Package files (package.mist) must output as <dir>/mod.rs so the Rust module
+    // hierarchy resolves correctly (pub mod <child>; declarations look for sibling
+    // .rs files, and the parent module declaration looks for <dir>/mod.rs).
+    if mist_path.file_name().and_then(|n| n.to_str()) == Some("package.mist") {
+        rust_path.set_file_name("mod.rs");
     }
 
-            if should_skip(&path, &dest_path) {
-                continue;
+    let parsed = parse(source).map_err(TranspileError::Parse)?;
+
+    for item in &parsed.items {
+        mist_parser::semantics::check_class_semantics(item).map_err(TranspileError::Semantic)?;
     }
 
-            if let Err(e) = fs::copy(&path, &dest_path) {
-                eprintln!(
-                    "Warning: Failed to copy non-mist file {}: {}",
-                    path.display(),
-                    e
-                );
-            }
-            continue;
+    let mut codegen = RustCodegen::new(mist_path.to_path_buf());
+
+    codegen.generate(parsed.mod_attributes);
+
+    codegen.add(extra_mod_decl);
+
+    let output = codegen.generate(parsed.items);
+
+    Ok(TranspiledFile {
+        mist_path: mist_path.to_path_buf(),
+        rust_path,
+        rust_content: output,
+        mapping: codegen.mapping,
+    })
 }
 
-        let output_path = out_dir.join(relative).with_extension("rs");
-
-        // Cache layer: Skip if the generated .rs file is newer than the .mist source
-        if should_skip(&path, &output_path) {
-            continue;
+/// No Semantics
+pub fn transpile_mist_no_sem(
+    mist_path: &Path,
+    source: &str,
+    extra_mod_decl: &str,
+) -> Result<TranspiledFile, String> {
+    let mut rust_path = crate::from_mist_to_rust(mist_path.to_path_buf());
+    // Package files (package.mist) must output as <dir>/mod.rs so the Rust module
+    // hierarchy resolves correctly (pub mod <child>; declarations look for sibling
+    // .rs files, and the parent module declaration looks for <dir>/mod.rs).
+    if mist_path.file_name().and_then(|n| n.to_str()) == Some("package.mist") {
+        rust_path.set_file_name("mod.rs");
     }
 
-        if let Err(e) = transpile_file(&path, &output_path) {
-            eprintln!(
-                "Warning: Transpilation failed for {}: {}",
-                path.display(),
-                e
-            );
-        }
+    let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
+
+    let mut codegen = RustCodegen::new(mist_path.to_path_buf());
+
+    codegen.generate(parsed.mod_attributes);
+
+    codegen.add(extra_mod_decl);
+
+    let output = codegen.generate(parsed.items);
+
+    Ok(TranspiledFile {
+        mist_path: mist_path.to_path_buf(),
+        rust_path,
+        rust_content: output,
+        mapping: codegen.mapping,
+    })
 }
 
-    Ok(())
-}
+pub fn format_mist(source: &str, config: MistFmtConfig) -> Result<String, String> {
+    let parsed = parse(source).map_err(|e| format!("parse error: {e:?}"))?;
 
-pub fn transpile_file(path: &Path, output_path: &Path) -> Result<(), String> {
-    // Create parent directories
-    if let Some(parent) = output_path.parent() {
-        fs::create_dir_all(parent).map_err(|e| {
-            format!(
-                "failed to create output directory {}: {}",
-                parent.display(),
-                e
-            )
-        })?;
-    }
+    let mut codegen = MistCodegen::new(config);
+    codegen.generate(parsed.mod_attributes);
+    let output = codegen.generate(parsed.items);
 
-    // Read source
-    let source = fs::read_to_string(path)
-        .map_err(|e| format!("failed to read file {}: {}", path.display(), e))?;
-
-    let parser_result = mist_parser::parse(&source).map_err(|e| match e {
-        ParseError::Ast(e) => {
-            // Using components carefully to prevent out-of-bounds or zero layout crashes
-            let start_pos = e.span.start_pos().line_col();
-            let span = e.span.as_str();
-
-            format!(
-                "\n{}:{}:{}\n Error: {}\n\t{}{}\t{}",
-                path.display(),
-                start_pos.0,
-                start_pos.1,
-                e.error_message,
-                span,
-                if span.ends_with('\n') { "" } else { "\n" },
-                "^".repeat(span.trim().len()),
-            )
-        }
-        ParseError::PreAst(e) => format!("{e}"),
-    });
-
-    // If parsing fails, return the error string back gracefully so the LSP can show it
-    let ast = parser_result.map_err(|e| format!("parse failed in {}:\n{}", path.display(), e))?;
-
-    let mut gc = mist_codegen::RustCodegen::new();
-    let output = gc.generate(ast);
-
-    fs::write(output_path, output)
-        .map_err(|e| format!("failed to write output {}: {}", output_path.display(), e))?;
-
-    Ok(())
-}
-
-pub fn transpile_text<'a>(source: &'a str) -> Result<String, ParseError<'a, Vec<TopLevel>>> {
-    let mut gc = mist_codegen::RustCodegen::new();
-
-    Ok(gc.generate(mist_parser::parse(&source)?))
-}
-
-fn should_skip(source: &Path, output: &Path) -> bool {
-    if let (Ok(src_meta), Ok(out_meta)) = (fs::metadata(source), fs::metadata(output)) {
-        if let (Ok(src_time), Ok(out_time)) = (src_meta.modified(), out_meta.modified()) {
-            return out_time >= src_time;
-        }
-    }
-    false
+    Ok(output)
 }

crates/codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-codegen"
-version = "0.1.7-alpha.0"
+version = "0.3.7-alpha.0"
 edition = "2024"
 description = "The Mist programming language Rust code generator"
 license = "Apache-2.0"
@@ -9,4 +9,5 @@ keywords = ["compiler", "language", "mist"]
 categories = ["compilers"]
 
 [dependencies]
+bytecount = "0.6.9"
 mist-parser = { workspace = true }

crates/codegen/src/class_decl.rs

@@ -0,0 +1,620 @@
+use std::collections::HashMap;
+
+use mist_parser::ast::*;
+
+use crate::{Context, GenRust, GenSpanTranslation, GetRust, RustCodegen};
+
+pub struct ClassProcessedData {
+    visibility: Visibility,
+    name: Identifier,
+    generics: GenericsDecl,
+    inherits: Option<ExprPath>,
+    self_path: ExprPath,
+    self_ty: TypeExpr,
+    fields: Vec<Spanned<FieldDeclStmt>>,
+    constructor: Option<Spanned<ClassConstructor>>,
+    items: Vec<ClassItem>,
+    methods: Vec<Spanned<FunctionDecl>>,
+    v_table: Vec<Identifier>,
+    override_v_table: HashMap<Override, Spanned<Vec<Identifier>>>,
+}
+
+impl ClassProcessedData {
+    pub fn analyze(
+        visibility: &Visibility,
+        name: &Identifier,
+        generics: &GenericsDecl,
+        inherits: &Option<ExprPath>,
+        fields: &Vec<Spanned<FieldDeclStmt>>,
+        constructor: &Option<Spanned<ClassConstructor>>,
+        items: &Vec<ClassItem>,
+    ) -> Self {
+        let self_path = ExprPath(vec![ExprPathSegment {
+            ident: name.clone(),
+            generics: generics.clone().into(),
+        }]);
+
+        let self_ty = get_type_from_path(&self_path);
+
+        let methods = items
+            .iter()
+            .filter_map(|item| match item {
+                ClassItem::ImplDecl(_) => None,
+                ClassItem::Method(method) => Some(method.clone()),
+            })
+            .collect::<Vec<Spanned<FunctionDecl>>>();
+
+        let mut v_table = Vec::new();
+        let mut override_v_table = std::collections::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() {
+                            v_table.push(method.item.name.clone());
+                        }
+                    }
+                    Some(override_spec) => {
+                        override_v_table
+                            .entry(override_spec.clone())
+                            .or_insert_with(|| Spanned {
+                                line: method.line,
+                                column: method.column,
+                                item: Vec::new(),
+                            })
+                            .item
+                            .push(method.item.name.clone());
+                    }
+                }
+            }
+        }
+
+        ClassProcessedData {
+            visibility: visibility.clone(),
+            name: name.clone(),
+            generics: generics.clone(),
+            inherits: inherits.clone(),
+            self_path,
+            self_ty,
+            fields: fields.clone(),
+            constructor: constructor.clone(),
+            items: items.clone(),
+            methods,
+            v_table,
+            override_v_table,
+        }
+    }
+
+    // ── Stage 2: Code Emission ───────────────────────────────────────
+
+    pub fn emit(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+        ctx.expr_super = self.inherits.clone();
+
+        self.emit_struct_decl(cg);
+        self.emit_impl_block(ctx, cg);
+        self.emit_impl_decls(ctx, cg);
+        self.emit_deref_impls(cg);
+
+        ctx.expr_super = None;
+    }
+
+    fn emit_struct_decl(&self, cg: &mut RustCodegen) {
+        cg.addln(&format!(
+            "{}struct {}{} {{",
+            self.visibility.get_rust(),
+            self.name.get_rust(),
+            self.generics.get_rust()
+        ));
+        cg.indent += 1;
+
+        if let Some(ref inherits) = self.inherits {
+            cg.add_indented("pub _super: ");
+            cg.add(&get_type_from_path(inherits).get_rust());
+            cg.addln(",");
+        } else {
+            cg.add_indentedln("pub _vptr: &'static [*const std::ffi::c_void],");
+        }
+
+        for field in &self.fields {
+            field.gen_span(cg);
+            cg.add_indentedln(&field.item.decl.get_rust());
+        }
+
+        cg.indent -= 1;
+        cg.addln("}\n");
+    }
+
+    fn emit_impl_block(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+        cg.addln(&format!(
+            "impl{} {} {{",
+            self.generics.get_rust(),
+            self.self_ty.get_rust()
+        ));
+        cg.indent += 1;
+
+        self.emit_unified_vtable(cg);
+        self.emit_super_v_tests(cg);
+
+        if let Some(constructor) = &self.constructor {
+            self.emit_constructor(constructor, ctx, cg);
+        }
+        self.emit_methods(ctx, cg);
+
+        cg.indent -= 1;
+        cg.addln("}\n");
+    }
+
+    fn emit_unified_vtable(&self, cg: &mut RustCodegen) {
+        let has_parent = self.inherits.is_some();
+        let parent_path = self
+            .inherits
+            .as_ref()
+            .map(|p| p.get_rust())
+            .unwrap_or_default();
+
+        if has_parent {
+            cg.add_indentedln(&format!(
+                "pub const __PARENT_V_COUNT: usize = {}::__V_COUNT;",
+                parent_path
+            ));
+        } else {
+            cg.add_indentedln("pub const __PARENT_V_COUNT: usize = 0;");
+        }
+
+        for (i, method_name) in self.v_table.iter().enumerate() {
+            cg.add_indentedln(&format!(
+                "pub const __FN_{}: usize = Self::__PARENT_V_COUNT + {i};",
+                method_name.0.to_uppercase()
+            ));
+        }
+
+        cg.add_indentedln(&format!(
+            "pub const __V_COUNT: usize = Self::__PARENT_V_COUNT + {};",
+            self.v_table.len()
+        ));
+
+        cg.add_indentedln("pub const __V_TABLE: &'static [*const std::ffi::c_void] = &{");
+        cg.indent += 1;
+
+        if has_parent {
+            cg.add_indentedln("let mut table = [std::ptr::null(); Self::__V_COUNT];");
+
+            cg.add_indentedln(&format!("let parent_table = {}::__V_TABLE;", parent_path));
+            cg.add_indentedln(
+                "let mut i = 0; while i < Self::__PARENT_V_COUNT {{ table[i] = parent_table[i]; i += 1; }}",
+            );
+
+            for (override_tier, overriden_method_idents) in &self.override_v_table {
+                let base_class_path = override_tier
+                    .0
+                    .as_ref()
+                    .unwrap_or(self.inherits.as_ref().unwrap())
+                    .get_rust();
+                for method_ident in &overriden_method_idents.item {
+                    cg.add_indentedln(&format!(
+                        "table[{}::__FN_{}] = {}::__m_{} as *const std::ffi::c_void;",
+                        base_class_path,
+                        method_ident.0.to_uppercase(),
+                        self.self_path.get_rust(),
+                        method_ident.get_rust()
+                    ));
+                }
+            }
+
+            for method_name in &self.v_table {
+                cg.add_indentedln(&format!(
+                    "table[Self::__FN_{}] = Self::__m_{} as *const std::ffi::c_void;",
+                    method_name.0.to_uppercase(),
+                    method_name.get_rust()
+                ));
+            }
+
+            cg.add_indentedln("table");
+        } else {
+            cg.add_indentedln("[");
+            cg.indent += 1;
+            for method_name in &self.v_table {
+                cg.add_indentedln(&format!(
+                    "Self::__m_{} as *const std::ffi::c_void,",
+                    method_name.get_rust()
+                ));
+            }
+            cg.indent -= 1;
+            cg.add_indentedln("]");
+        }
+
+        cg.indent -= 1;
+        cg.add_indentedln("};");
+    }
+
+    fn emit_super_v_tests(&self, cg: &mut RustCodegen) {
+        cg.add_indentedln("#[allow(invalid_value)]");
+        cg.add_indentedln(&format!("fn __test_vt() {{"));
+        cg.indent += 1;
+
+        for (override_tier, _) in self.override_v_table.iter() {
+            let target_path = match &override_tier.0 {
+                Some(path) => path.clone(),
+
+                None => {
+                    if let Some(parent_path) = &self.inherits {
+                        parent_path.clone()
+                    } else {
+                        continue;
+                    }
+                }
+            };
+
+            let target_rust_path = target_path.get_rust();
+
+            for method in &self.methods {
+                if method.item.is_override.as_ref() == Some(override_tier) {
+                    let mut params = method
+                        .item
+                        .params
+                        .0
+                        .clone()
+                        .into_iter()
+                        .filter_map(|v| v.type_)
+                        .collect::<Vec<_>>();
+
+                    if params.is_empty() {
+                        continue;
+                    }
+
+                    if let Some((_, _, mutable)) = &method.item.self_param {
+                        method.gen_span(cg);
+                        cg.add_indented(&format!("{}::__m_", target_rust_path));
+                        cg.add(&method.item.name.get_rust());
+                        cg.add(" as ");
+
+                        params.insert(
+                            0,
+                            TypeExpr::Ref {
+                                lifetime: None,
+                                mutable: *mutable,
+                                ty: Box::new(get_type_from_path(&target_path)),
+                            },
+                        );
+
+                        cg.add(
+                            &TypeExpr::StaticFn(
+                                params,
+                                method.item.return_type.clone().map(Box::new),
+                            )
+                            .get_rust(),
+                        );
+                        cg.addln(";");
+                    }
+                }
+            }
+        }
+
+        // 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() };");
+
+            for (override_tier, v) in &self.override_v_table {
+                if let Some(path) = &override_tier.0 {
+                    v.gen_span(cg);
+                    // This forces the compiler to statically verify that &Self can Deref into &Target
+                    cg.add_indentedln(&format!("let _: &{} = this;", path.get_rust()));
+                }
+            }
+        }
+
+        cg.indent -= 1;
+        cg.add_indentedln("}");
+    }
+
+    fn emit_constructor(
+        &self,
+        constructor: &Spanned<ClassConstructor>,
+        ctx: &mut Context,
+        cg: &mut RustCodegen,
+    ) {
+        cg.add_indentedln("#[allow(invalid_value)]");
+        constructor.gen_span(cg);
+
+        cg.add_indented(&format!(
+            "{}fn new{}(",
+            constructor.item.visibility.get_rust(),
+            constructor.item.generics.get_rust()
+        ));
+
+        let params = constructor
+            .item
+            .params
+            .0
+            .clone()
+            .into_iter()
+            .enumerate()
+            .map(|(idx, mut v)| {
+                v.name = construct_pattern(&v.name, idx);
+                (idx, v)
+            })
+            .collect::<Vec<_>>();
+
+        for (i, param) in &params {
+            if *i > 0 {
+                cg.add(", ");
+            }
+            param.gen_rust(ctx, cg);
+        }
+
+        cg.addln(") -> Self {");
+        cg.indent += 1;
+
+        cg.add_indentedln("let mut this: Self = unsafe { std::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()));
+                init.gen_rust(ctx, cg);
+            }
+        }
+
+        cg.add_indented("this.constructor(");
+        for (i, param) in &params {
+            if *i > 0 {
+                cg.add(", ");
+            }
+            ctx.expr_ensure_semicolon = false;
+            param.name.gen_rust(ctx, cg);
+        }
+        cg.addln(");");
+
+        cg.add_indentedln("this._vptr = &Self::__V_TABLE;");
+
+        constructor.gen_span(cg);
+
+        cg.add_indentedln("this");
+        cg.indent -= 1;
+        cg.add_indentedln("}\n");
+
+        Spanned {
+            line: constructor.line,
+            column: constructor.column,
+            item: FunctionDecl {
+                visibility: constructor.item.visibility.clone(),
+                is_override: None,
+                name: Identifier(String::from("constructor")),
+                generics: constructor.item.generics.clone(),
+                params: constructor.item.params.clone(),
+                self_param: Some((true, None, true)),
+                return_type: Some(TypeExpr::Tuple(Vec::new())),
+                body: Some(constructor.item.body.clone()),
+            },
+        }
+        .gen_rust(ctx, cg);
+    }
+
+    fn emit_methods(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+        for method in &self.methods {
+            match method.item.visibility {
+                Visibility::Public => {
+                    if method.item.self_param.is_some() {
+                        if method.item.is_override.is_none() {
+                            gen_method_point(&method.item, ctx, cg);
+                        }
+
+                        let mut prefixed = method.clone();
+                        prefixed.item.name.0.insert_str(0, "__m_");
+                        prefixed.gen_rust(ctx, cg);
+                    } else {
+                        method.gen_rust(ctx, cg);
+                    }
+                }
+                _ => {
+                    method.gen_rust(ctx, cg);
+                }
+            }
+        }
+    }
+
+    fn emit_impl_decls(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+        for item in &self.items {
+            if let ClassItem::ImplDecl(impl_) = item {
+                let mut impl_ = impl_.clone();
+                impl_.item.trait_ = Some(impl_.item.target);
+                impl_.item.target = TypeExpr::Path(Path(vec![self.name.clone()]), None);
+                impl_.gen_rust(ctx, cg);
+            }
+        }
+    }
+
+    fn emit_deref_impls(&self, cg: &mut RustCodegen) {
+        if let Some(ref inherits) = self.inherits {
+            let generics_str = self.generics.get_rust();
+            let generics_expr_str = Generics::from(self.generics.clone()).get_rust();
+
+            cg.add(&format!(
+                "impl{} std::ops::Deref for {}{}",
+                generics_str,
+                self.name.get_rust(),
+                generics_expr_str
+            ));
+
+            cg.addln(" {");
+            cg.indent += 1;
+
+            cg.add_indented("type Target = ");
+            cg.add(&inherits.get_rust());
+            cg.addln(";");
+
+            cg.add_indentedln("fn deref(&self) -> &Self::Target { &self._super }");
+
+            cg.indent -= 1;
+            cg.addln("}");
+
+            cg.add(&format!(
+                "impl{} std::ops::DerefMut for {}{}",
+                generics_str,
+                self.name.get_rust(),
+                generics_expr_str
+            ));
+
+            cg.addln(" {");
+            cg.indent += 1;
+
+            cg.add_indentedln("fn deref_mut(&mut self) -> &mut Self::Target { &mut self._super }");
+
+            cg.indent -= 1;
+            cg.addln("}");
+        }
+    }
+}
+
+pub fn class_decl(
+    ctx: &mut Context,
+    cg: &mut RustCodegen,
+    visibility: &Visibility,
+    name: &Identifier,
+    generics: &GenericsDecl,
+    inherits: &Option<ExprPath>,
+    fields: &Vec<Spanned<FieldDeclStmt>>,
+    constructor: &Option<Spanned<ClassConstructor>>,
+    items: &Vec<ClassItem>,
+) {
+    let data = ClassProcessedData::analyze(
+        visibility,
+        name,
+        generics,
+        inherits,
+        fields,
+        constructor,
+        items,
+    );
+    data.emit(ctx, cg);
+}
+
+fn construct_pattern(pat: &Pattern, idx: usize) -> Pattern {
+    match pat {
+        Pattern::Literal(v) => Pattern::Literal(v.clone()),
+        Pattern::Path(is_mut, v) => Pattern::Path(*is_mut, v.clone().into()),
+        _ => Pattern::Path(false, Path(vec![Identifier(format!("_{idx}"))])),
+    }
+}
+
+pub fn gen_method_point(method: &FunctionDecl, ctx: &mut Context, cg: &mut RustCodegen) {
+    let mutable_self = if let Some((is_ref, lifetime, is_mut)) = &method.self_param {
+        cg.add_indented(&format!(
+            "{}fn {}{}(",
+            method.visibility.get_rust(),
+            method.name.get_rust(),
+            method.generics.get_rust(),
+        ));
+
+        if *is_ref {
+            cg.add("&");
+        }
+
+        if let Some(lifetime) = lifetime {
+            cg.add(&format!("'{} ", lifetime.0));
+        }
+
+        if *is_mut {
+            cg.add("mut ");
+        }
+
+        cg.add("self,");
+
+        *is_mut
+    } else {
+        panic!();
+    };
+
+    let params = method
+        .params
+        .0
+        .clone()
+        .into_iter()
+        .enumerate()
+        .map(|(idx, mut v)| {
+            v.name = construct_pattern(&v.name, idx);
+            (idx, v)
+        })
+        .collect::<Vec<_>>();
+
+    for (i, param) in &params {
+        if *i > 0 {
+            cg.add(", ");
+        }
+        param.gen_rust(ctx, cg);
+    }
+
+    cg.add(") ");
+    if let Some(return_type) = &method.return_type {
+        cg.add("-> ");
+        cg.add(&return_type.get_rust());
+    }
+
+    cg.addln("{");
+    cg.indent += 1;
+
+    cg.add_indentedln("unsafe {");
+    cg.indent += 1;
+
+    cg.add_indentedln(&format!(
+        "let func_ptr = self._vptr[Self::__FN_{}];",
+        method.name.0.to_uppercase()
+    ));
+
+    cg.add_indented("let func: ");
+
+    let mut param_types: Vec<TypeExpr> = method
+        .params
+        .clone()
+        .0
+        .into_iter()
+        .filter_map(|v| v.type_)
+        .collect();
+
+    param_types.insert(
+        0,
+        TypeExpr::UnsafePtr {
+            mutable: mutable_self,
+            ty: Box::new(TypeExpr::Path(
+                Path(vec![
+                    Identifier(String::from("std")),
+                    Identifier(String::from("ffi")),
+                    Identifier(String::from("c_void")),
+                ]),
+                None,
+            )),
+        },
+    );
+
+    cg.add(&TypeExpr::StaticFn(param_types, method.return_type.clone().map(Box::new)).get_rust());
+    cg.addln(" = std::mem::transmute(func_ptr);");
+
+    if mutable_self {
+        cg.add_indented("func(self as *mut Self as *const std::ffi::c_void");
+    } else {
+        cg.add_indented("func(self as *const Self as *const std::ffi::c_void");
+    }
+
+    for (_, param) in &params {
+        cg.add(", ");
+        ctx.expr_ensure_semicolon = false;
+        param.name.gen_rust(ctx, cg);
+    }
+
+    cg.addln(")");
+
+    cg.indent -= 1;
+    cg.add_indentedln("}");
+
+    cg.indent -= 1;
+    cg.add_indentedln("}");
+}
+
+pub fn get_type_from_path(path: &ExprPath) -> TypeExpr {
+    TypeExpr::Path(
+        Path(path.0.iter().map(|v| v.ident.clone()).collect::<Vec<_>>()),
+        path.0.last().unwrap().generics.clone(),
+    )
+}

crates/codegen/src/expr.rs

@@ -12,6 +12,20 @@ impl GetRust for ExprPath {
             .collect::<Vec<_>>()
             .join("::")
     }
+
+    fn get_rust_ctx(&self, cx: &mut Context) -> String {
+        let mut a = self.clone();
+
+        if let Some(path) = &cx.expr_super {
+            if self.0[0].ident.0 == "super" && self.0.len() == 1 {
+                a.0[0].ident.0 = String::from("self._super");
+            } else if self.0[0].ident.0 == "Super" {
+                a.0[0] = path.0[0].clone();
+            }
+        }
+
+        a.get_rust()
+    }
 }
 
 impl GetRust for ExprPathSegment {
@@ -38,30 +52,16 @@ impl GenRust for Literal {
             Self::Tuple(values) => {
                 cg.add("(");
 
-                for val in values {
+                for (i, val) in values.iter().enumerate() {
+                    if i > 0 {
+                        cg.add(", ");
+                    }
+
                     val.gen_rust(ctx, cg);
                 }
 
                 cg.add(")");
             }
-
-            Self::Array(values) => {
-                cg.add("[");
-
-                for val in values {
-                    val.gen_rust(ctx, cg);
-                }
-
-                cg.add("]");
-            }
-
-            Self::ArrayRepeat(value, repeat) => {
-                cg.add("[");
-                value.gen_rust(ctx, cg);
-                cg.add("; ");
-                repeat.gen_rust(ctx, cg);
-                cg.add("]");
-            }
         }
     }
 }
@@ -77,9 +77,29 @@ impl GenRust for Expression {
         };
 
         match self {
-            Expression::Path(path) => cg.add(&path.get_rust()),
+            Expression::Path(path) => cg.add(&path.get_rust_ctx(ctx)),
             Expression::Literal(literal) => literal.gen_rust(ctx, cg),
             Expression::Statement(stmt) => stmt.gen_rust(ctx, cg),
+            Expression::Array(values) => {
+                cg.add("[");
+
+                for (i, val) in values.iter().enumerate() {
+                    if i > 0 {
+                        cg.add(", ");
+                    }
+
+                    val.gen_rust(ctx, cg);
+                }
+
+                cg.add("]");
+            }
+            Expression::ArrayRepeat(value, repeat) => {
+                cg.add("[");
+                value.gen_rust(ctx, cg);
+                cg.add("; ");
+                repeat.gen_rust(ctx, cg);
+                cg.add("]");
+            }
             Expression::Fix {
                 initial,
                 prefixes,
@@ -87,19 +107,52 @@ impl GenRust for Expression {
             } => {
                 prefixes.gen_rust(ctx, cg);
                 initial.gen_rust(ctx, cg);
-                cg.add(&Some(prefixes).get_rust());
                 for postfix in postfixes {
                     postfix.gen_rust(ctx, cg);
                 }
             }
-            // Safely integrated to handle the tree structure built by the Pratt Parser
+
             Expression::Binary { lhs, op, rhs } => {
+                if op == "->" {
+                    cg.add("unsafe { std::ptr::write(&mut ");
+                    lhs.gen_rust(ctx, cg);
+                    cg.add(", ");
+                    rhs.gen_rust(ctx, cg);
+                    cg.add(") }");
+                } else {
                     lhs.gen_rust(ctx, cg);
                     cg.add(op);
                     rhs.gen_rust(ctx, cg);
                 }
             }
 
+            Expression::Closure {
+                return_type,
+                params,
+                body,
+            } => {
+                cg.add("|");
+                for (i, arg) in params.iter().enumerate() {
+                    if i > 0 {
+                        cg.add(", ");
+                    }
+
+                    arg.gen_rust(ctx, cg);
+                }
+                cg.add("| ");
+
+                if let Some(ty) = return_type {
+                    cg.add("-> ");
+                    cg.add(&ty.get_rust());
+                    cg.add(" ");
+
+                    cg.ensure_brackets_expr(ctx, body);
+                } else {
+                    body.gen_rust(ctx, cg);
+                }
+            }
+        }
+
         if ensure_semicolon {
             ctx.expr_ensure_semicolon = true;
 
@@ -111,31 +164,13 @@ impl GenRust for Expression {
 }
 
 impl GenRust for Prefix {
-    fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+    fn gen_rust(&self, _ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
             Self::Deref => cg.add("*"),
             Self::Ref => cg.add("&"),
             Self::RefMut => cg.add("&mut "),
             Self::Not => cg.add("!"),
-            Self::New(_) => cg.add(""),
             Self::Neg => cg.add("-"),
-            Self::Closure(ty, args) => {
-                cg.add("|");
-                for (i, arg) in args.iter().enumerate() {
-                    if i > 0 {
-                        cg.add(", ");
-                    }
-
-                    arg.gen_rust(ctx, cg);
-                }
-                cg.add("| ");
-
-                if let Some(ty) = ty {
-                    cg.add("-> ");
-                    cg.add(&ty.get_rust());
-                    cg.add(" ");
-                }
-            }
         }
     }
 }
@@ -148,33 +183,17 @@ impl GenRust for Vec<Prefix> {
     }
 }
 
-impl GetRust for Option<&Vec<Prefix>> {
-    fn get_rust(&self) -> String {
-        if let Some(prefixes) = self {
-            prefixes
-                .into_iter()
-                .last()
-                .map(|p| match p {
-                    Prefix::New(generics) => format!(
-                        "::new{}",
-                        generics
-                            .clone()
-                            .map(|v| format!("::{}", v.get_rust()))
-                            .unwrap_or_default(),
-                    ),
-                    _ => String::new(),
-                })
-                .unwrap_or_default()
-                .to_string()
-        } else {
-            String::new()
-        }
-    }
-}
-
 impl GenRust for Postfix {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
+            Postfix::TupleFieldAccess(field, generics) => cg.add(&format!(
+                ".{}{}",
+                field,
+                generics
+                    .iter()
+                    .map(|v| format!("::{}", v.get_rust()))
+                    .collect::<String>()
+            )),
             Postfix::FieldAccess(field, generics) => cg.add(&format!(
                 ".{}{}",
                 field.get_rust(),
@@ -198,10 +217,15 @@ impl GenRust for Postfix {
                 cg.add(")");
             }
 
-            Postfix::MacroCall(inner) => {
-                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(")");
+                cg.add(close);
             }
 
             Postfix::StructCall(fields) => {
@@ -209,8 +233,10 @@ impl GenRust for Postfix {
 
                 for (name, expr) in fields {
                     cg.add(&name.get_rust());
+                    if let Some(expr) = expr {
                         cg.add(": ");
                         expr.gen_rust(ctx, cg);
+                    }
                     cg.add(",");
                 }
 
@@ -230,11 +256,6 @@ impl GenRust for Postfix {
 
             Postfix::Try => cg.add("?"),
 
-            Postfix::Assign(cmp, expr) => {
-                cg.add(" ");
-                cg.add(cmp);
-                expr.gen_rust(ctx, cg);
-            }
             Postfix::Increment => cg.add("+=1"),
             Postfix::Decrement => cg.add("-=1"),
         }

crates/codegen/src/fmt/expr.rs

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,450 @@
+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

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,336 @@
+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,11 +1,19 @@
+pub mod class_decl;
 pub mod expr;
+pub mod fmt;
 pub mod statement;
 pub mod top_level;
 
-use mist_parser::ast::*;
+use std::path::PathBuf;
+
+use mist_parser::{
+    ast::*,
+    rev_mapper::{Mapping, MistMap, RustMap},
+};
 
 pub struct Context {
     pub expr_ensure_semicolon: bool,
+    pub expr_super: Option<ExprPath>,
 }
 
 pub trait GenRust {
@@ -14,19 +22,26 @@ pub trait GenRust {
 
 pub trait GetRust {
     fn get_rust(&self) -> String;
+    fn get_rust_ctx(&self, cx: &mut Context) -> String {
+        let _ = cx;
+        self.get_rust()
+    }
 }
 
-#[derive(Default)]
 pub struct RustCodegen {
     output: String,
     indent: usize,
+    pub mapping: Mapping,
+    position: RustMap,
 }
 
 impl RustCodegen {
-    pub fn new() -> Self {
+    pub fn new(mist_path: PathBuf) -> Self {
         Self {
             output: String::new(),
             indent: 0,
+            mapping: Mapping::new(mist_path),
+            position: RustMap(1, 0),
         }
     }
 
@@ -34,21 +49,32 @@ impl RustCodegen {
         "    ".repeat(self.indent)
     }
 
-    fn add(&mut self, s: &str) {
+    pub fn add(&mut self, s: &str) {
+        let newline_count = bytecount::count(s.as_bytes(), b'\n');
+
+        if newline_count == 0 {
+            self.position.1 += s.len();
+        } else {
+            self.position.0 += newline_count;
+
+            let last_newline = s.rfind('\n').unwrap();
+            self.position.1 = s.len() - last_newline - 1;
+        }
+
         self.output.push_str(s);
     }
 
-    fn addln(&mut self, s: &str) {
+    pub fn addln(&mut self, s: &str) {
         self.add(s);
         self.add("\n");
     }
 
-    fn add_indented(&mut self, s: &str) {
+    pub fn add_indented(&mut self, s: &str) {
         let line = format!("{}{}", self.indent_str(), s);
         self.add(&line);
     }
 
-    fn add_indentedln(&mut self, s: &str) {
+    pub fn add_indentedln(&mut self, s: &str) {
         let line = format!("{}{}\n", self.indent_str(), s);
         self.add(&line);
     }
@@ -56,6 +82,7 @@ impl RustCodegen {
     pub fn generate(&mut self, toplevels: Vec<TopLevel>) -> String {
         let mut ctx = Context {
             expr_ensure_semicolon: true,
+            expr_super: None,
         };
 
         for tl in toplevels {
@@ -90,17 +117,6 @@ impl RustCodegen {
             }
         }
     }
-
-    pub fn ensure_brackets_body(&mut self, ctx: &mut Context, body: &StatementBody) {
-        match body {
-            StatementBody::Expression(expr) => self.ensure_brackets_expr(ctx, expr),
-
-            StatementBody::Statement(expr) => {
-                ctx.expr_ensure_semicolon = true;
-                self.ensure_brackets_expr(ctx, expr);
-            }
-        }
-    }
 }
 
 impl GenRust for Attribute {
@@ -127,21 +143,27 @@ impl GenRust for Attribute {
     }
 }
 
-impl<T: GetRust> GetRust for Spanned<T> {
-    fn get_rust(&self) -> String {
-        format!(
-            "/* {}:{} */ {}",
-            self.line,
-            self.column,
-            self.item.get_rust()
-        )
+pub trait GenSpanTranslation {
+    fn gen_span(&self, _cg: &mut RustCodegen);
+}
+
+impl<T> GenSpanTranslation for Spanned<T> {
+    fn gen_span(&self, cg: &mut RustCodegen) {
+        cg.mapping
+            .map
+            .insert((cg.position, MistMap(self.line, self.column)));
+    }
+}
+
+impl<T: GetRust> GenRust for T {
+    fn gen_rust(&self, _: &mut Context, cg: &mut RustCodegen) {
+        cg.add(&self.get_rust());
     }
 }
 
 impl<T: GenRust> GenRust for Spanned<T> {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        cg.add_indentedln(&format!("/* {}:{} */", self.line, self.column));
-        cg.add_indented("");
+        self.gen_span(cg);
         self.item.gen_rust(ctx, cg);
     }
 }
@@ -156,18 +178,6 @@ impl GetRust for Path {
     }
 }
 
-impl GetRust for TypePostfix {
-    fn get_rust(&self) -> String {
-        match self {
-            TypePostfix::Ref => format!("&"),
-            TypePostfix::RefMut => format!("&mut "),
-            TypePostfix::RefLifetime(lifetime) => format!("&'{} ", lifetime.get_rust()),
-            TypePostfix::RefMutLifetime(lifetime) => format!("&'{} mut ", lifetime.get_rust()),
-            TypePostfix::Dyn => format!("dyn "),
-        }
-    }
-}
-
 impl GetRust for Visibility {
     fn get_rust(&self) -> String {
         match self {
@@ -185,43 +195,17 @@ impl GetRust for Identifier {
 }
 
 impl GetRust for TypeExpr {
-    fn get_rust(&self) -> String {
-        self.1
-            .iter()
-            .map(TypePostfix::get_rust)
-            .rev()
-            .collect::<String>()
-            + &self.0.get_rust()
-    }
-}
-
-pub fn get_static_type_path(path: &Path) -> String {
-    let rust_path = path.get_rust();
-
-    if rust_path == "void" {
-        format!("()")
-    } else {
-        rust_path
-    }
-}
-
-impl GetRust for TypeExprKind {
     fn get_rust(&self) -> String {
         match self {
-            TypeExprKind::Path(path) => get_static_type_path(path),
-            TypeExprKind::Lifetime(name) => format!("'{}", name.get_rust()),
-            TypeExprKind::PathParams(path, params) => {
-                format!(
-                    "{}<{}>",
-                    get_static_type_path(path),
-                    params
-                        .into_iter()
-                        .map(|t| t.get_rust())
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
+            Self::Path(path, generics) => {
+                if let Some(generics) = generics {
+                    format!("{}{}", path.get_rust(), generics.get_rust())
+                } else {
+                    path.get_rust()
                 }
-            TypeExprKind::Tuple(types) => format!(
+            }
+            Self::Lifetime(name) => format!("'{}", name.get_rust()),
+            Self::Tuple(types) => format!(
                 "({})",
                 types
                     .into_iter()
@@ -229,13 +213,93 @@ impl GetRust for TypeExprKind {
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
+            Self::StaticFn(types, return_type) => {
+                if let Some(return_type) = return_type {
+                    format!(
+                        "fn({}) -> {}",
+                        types
+                            .into_iter()
+                            .map(|t| t.get_rust())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                        return_type.get_rust()
+                    )
+                } else {
+                    format!(
+                        "fn({})",
+                        types
+                            .into_iter()
+                            .map(|t| t.get_rust())
+                            .collect::<Vec<_>>()
+                            .join(", "),
+                    )
                 }
             }
+
+            Self::UnsafePtr { mutable, ty } => {
+                let mutable = if *mutable { "mut " } else { "const " };
+                format!("*{mutable}{}", ty.get_rust())
+            }
+
+            Self::Ref {
+                lifetime,
+                mutable,
+                ty,
+            } => {
+                if let Some(lifetime) = lifetime {
+                    format!(
+                        "&'{} {}{}",
+                        lifetime.get_rust(),
+                        if *mutable { "mut " } else { "" },
+                        ty.get_rust()
+                    )
+                } else {
+                    format!("&{}{}", if *mutable { "mut " } else { "" }, ty.get_rust())
+                }
+            }
+
+            Self::Dyn(ty) => {
+                format!("dyn {}", ty.get_rust())
+            }
+            Self::Void => "()".to_string(),
+            Self::Fn {
+                kind,
+                return_type,
+                params,
+            } => {
+                format!(
+                    "{}({}) -> {}",
+                    kind.get_rust(),
+                    params
+                        .iter()
+                        .map(TypeExpr::get_rust)
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                    return_type.get_rust(),
+                )
+            }
+        }
+    }
+}
+
+impl GetRust for FnKind {
+    fn get_rust(&self) -> String {
+        match self {
+            Self::Fn => "fn",
+            Self::UnsafeFn => "unsafe fn",
+            Self::FnClosure => "Fn",
+            Self::FnMut => "FnMut",
+            Self::FnOnce => "FnOnce",
+        }
+        .to_string()
+    }
 }
 
 impl GenRust for Pattern {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
+            Self::Etc => cg.add(".."),
+            Self::Literal(lit) => lit.gen_rust(ctx, cg),
             Self::Path(mutable, path) => {
                 if *mutable {
                     cg.add("mut ");
@@ -243,15 +307,26 @@ impl GenRust for Pattern {
 
                 cg.add(&path.get_rust())
             }
-            Self::Literal(lit) => lit.gen_rust(ctx, cg),
-
             Self::Struct(path, inner) => {
                 cg.add(&path.get_rust());
                 cg.add(" {");
-                for pat in inner {
-                    pat.gen_rust(ctx, cg);
+
+                for (idx, i) in inner.iter().enumerate() {
+                    if idx > 0 {
                         cg.add(", ");
                     }
+
+                    if let Some((name, pat)) = i {
+                        cg.add(&name.get_rust());
+                        if let Some(pat) = pat {
+                            cg.add(": ");
+                            pat.gen_rust(ctx, cg);
+                        }
+                    } else {
+                        cg.add("..");
+                    }
+                }
+
                 cg.add("}");
             }
 

crates/codegen/src/statement.rs

@@ -1,6 +1,6 @@
 use mist_parser::ast::*;
 
-use crate::Context;
+use crate::{Context, GenSpanTranslation};
 
 use crate::{GenRust, GetRust, RustCodegen};
 
@@ -9,14 +9,16 @@ impl GenRust for Block {
         cg.addln("{");
         cg.indent += 1;
 
-        for stmt in &self.0 {
+        for stmt in &self.statements {
             ctx.expr_ensure_semicolon = true;
+            cg.add_indented("");
             stmt.gen_rust(ctx, cg);
             cg.addln("");
         }
 
-        if let Some(soft_return) = &self.1 {
+        if let Some(soft_return) = &self.soft_return {
             ctx.expr_ensure_semicolon = false;
+            cg.add_indented("");
             soft_return.gen_rust(ctx, cg);
             cg.addln("");
         }
@@ -26,21 +28,14 @@ impl GenRust for Block {
     }
 }
 
-impl GenRust for StatementBody {
-    fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        match self {
-            Self::Expression(expr) => expr.gen_rust(ctx, cg),
-            Self::Statement(stmt) => {
-                ctx.expr_ensure_semicolon = true;
-                stmt.gen_rust(ctx, cg);
-            }
-        }
-    }
-}
-
 impl GenRust for Statement {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
+            Statement::UnsafeBlock(block) => {
+                cg.add("unsafe ");
+                block.gen_rust(ctx, cg);
+            }
+
             Statement::Block(block) => block.gen_rust(ctx, cg),
 
             Statement::VarDecl(VarDeclStmt { decl, init }) => {
@@ -60,7 +55,7 @@ impl GenRust for Statement {
                 cg.indent += 1;
 
                 for match_item in match_items {
-                    cg.add_indentedln(&match_item.get_comment());
+                    match_item.gen_span(cg);
 
                     let MatchItem(pat, body) = &match_item.item;
 
@@ -90,20 +85,22 @@ impl GenRust for Statement {
                 else_branch,
             } => {
                 cg.add("if ");
+                ctx.expr_ensure_semicolon = false;
                 initial.condition.gen_rust(ctx, cg);
                 cg.add(" ");
-                cg.ensure_brackets_body(ctx, &initial.body);
+                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(" ");
-                    cg.ensure_brackets_body(ctx, &else_if_branch.body);
+                    else_if_branch.body.gen_rust(ctx, cg);
                 }
 
                 if let Some(else_br) = else_branch {
                     cg.add(" else ");
-                    cg.ensure_brackets_body(ctx, else_br);
+                    else_br.gen_rust(ctx, cg);
                 }
             }
 
@@ -111,12 +108,12 @@ impl GenRust for Statement {
                 cg.add("while ");
                 condition.gen_rust(ctx, cg);
                 cg.add(" ");
-                cg.ensure_brackets_body(ctx, body);
+                body.gen_rust(ctx, cg);
             }
 
             Statement::Loop(body) => {
                 cg.add("loop ");
-                cg.ensure_brackets_body(ctx, body);
+                body.gen_rust(ctx, cg);
             }
 
             Statement::CStyleFor {
@@ -170,7 +167,7 @@ impl GenRust for Statement {
                 pattern.gen_rust(ctx, cg);
                 cg.add(" in ");
                 iterator.gen_rust(ctx, cg);
-                cg.ensure_brackets_body(ctx, body);
+                body.gen_rust(ctx, cg);
             }
 
             Statement::Return(expr) => {

crates/codegen/src/top_level.rs

@@ -1,6 +1,6 @@
 use mist_parser::ast::*;
 
-use crate::Context;
+use crate::{Context, class_decl};
 
 use crate::{GenRust, GetRust, RustCodegen};
 
@@ -73,13 +73,29 @@ impl GenRust for ImplDecl {
 
 impl GenRust for FunctionDecl {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        cg.add(&format!(
+        cg.add_indented(&format!(
             "{}fn {}{}(",
             self.visibility.get_rust(),
             self.name.get_rust(),
             self.generics.get_rust(),
         ));
 
+        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,");
+        }
+
         for (i, param) in self.params.0.iter().enumerate() {
             if i > 0 {
                 cg.add(", ");
@@ -88,14 +104,18 @@ impl GenRust for FunctionDecl {
             param.gen_rust(ctx, cg);
         }
 
-        cg.add(") -> ");
-        cg.add(&self.return_type.get_rust());
+        cg.add(") ");
+        if let Some(return_type) = &self.return_type {
+            cg.add("-> ");
+            cg.add(&return_type.get_rust());
+        }
 
         if let Some(body) = &self.body {
             cg.add(" ");
             body.gen_rust(ctx, cg);
+            cg.addln("");
         } else {
-            cg.add(";");
+            cg.addln(";");
         }
     }
 }
@@ -167,76 +187,6 @@ impl GenRust for TopLevel {
     }
 }
 
-impl GenRust for (&Vec<Spanned<FieldDeclStmt>>, &Spanned<ClassConstructor>) {
-    fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
-        cg.add_indented(&format!(
-            "{}fn new{}(",
-            self.1.item.visibility.get_rust(),
-            self.1.item.generics.get_rust()
-        ));
-
-        self.1.item.params.gen_rust(ctx, cg);
-
-        cg.addln(") -> Self {");
-        cg.indent += 1;
-
-        cg.add_indentedln("let mut this: Self = unsafe { std::mem::MaybeUninit::<Self>::zeroed().assume_init() };");
-
-        for field in self.0 {
-            let comment = field.get_comment();
-
-            if let Some(init) = &field.item.init {
-                cg.add_indentedln(&comment);
-
-                cg.add_indentedln(&format!("this.{} = ", field.item.decl.name.get_rust()));
-
-                init.gen_rust(ctx, cg);
-            }
-        }
-
-        cg.add_indented(&format!("this.constructor("));
-
-        for (i, param) in self.1.item.params.0.iter().enumerate() {
-            if i > 0 {
-                cg.add(", ");
-            }
-
-            param.name.gen_rust(ctx, cg);
-        }
-
-        cg.addln(");");
-
-        cg.add_indentedln("this");
-
-        cg.indent -= 1;
-        cg.add_indentedln("}\n");
-
-        let mut constructor_params = vec![VarDecl {
-            name: Pattern::Path(false, Path(vec![Identifier(String::from("self"))])),
-            type_: Some(TypeExpr(
-                TypeExprKind::Path(Path(vec![Identifier(String::from("Self"))])),
-                vec![TypePostfix::RefMut],
-            )),
-        }];
-
-        constructor_params.append(&mut self.1.item.params.0.clone());
-
-        Spanned {
-            line: self.1.line,
-            column: self.1.column,
-            item: FunctionDecl {
-                visibility: self.1.item.visibility.clone(),
-                name: Identifier(String::from("constructor")),
-                generics: self.1.item.generics.clone(),
-                params: ParamList(constructor_params),
-                return_type: TypeExpr::no_px(TypeExprKind::Tuple(Vec::new())),
-                body: Some(self.1.item.body.clone()),
-            },
-        }
-        .gen_rust(ctx, cg);
-    }
-}
-
 impl GenRust for TopLevelKind {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
@@ -244,7 +194,7 @@ impl GenRust for TopLevelKind {
             Self::Import(vis, path) => {
                 cg.addln(&format!("{}use {};", vis.get_rust(), path.get_rust()))
             }
-            Self::Mod(vis, id) => cg.addln(&format!("{}mod {};", vis.get_rust(), id.get_rust())),
+            Self::DeclareModule(_, _) => {}
             Self::FunctionDecl(decl) => decl.gen_rust(ctx, cg),
             Self::ImplDecl(impl_) => impl_.gen_rust(ctx, cg),
             Self::StructDecl {
@@ -262,7 +212,9 @@ impl GenRust for TopLevelKind {
                 cg.indent += 1;
 
                 for field in fields {
-                    cg.add_indentedln(&field.get_rust());
+                    cg.add_indented("");
+                    field.gen_rust(ctx, cg);
+                    cg.addln("");
                 }
 
                 cg.indent -= 1;
@@ -283,7 +235,9 @@ impl GenRust for TopLevelKind {
                 cg.indent += 1;
 
                 for field in fields {
-                    cg.add_indentedln(&(field.get_rust() + ","));
+                    cg.add_indented("");
+                    field.gen_rust(ctx, cg);
+                    cg.addln(",");
                 }
 
                 cg.indent -= 1;
@@ -329,112 +283,17 @@ impl GenRust for TopLevelKind {
                 fields,
                 constructor,
                 items,
-            } => {
-                // Struct decl
-                cg.addln(&format!(
-                    "{}struct {}{} {{",
-                    visibility.get_rust(),
-                    name.clone().get_rust(),
-                    generics.clone().get_rust()
-                ));
-                cg.indent += 1;
-
-                if let Some(inherits) = inherits {
-                    cg.add_indented("pub _super: ");
-                    cg.add(&inherits.get_rust());
-                    cg.addln(",");
-                }
-
-                for field in fields.clone() {
-                    cg.add_indentedln(&field.get_comment());
-                    cg.add_indentedln(&field.item.decl.get_rust());
-                }
-
-                cg.indent -= 1;
-                cg.addln("}\n");
-
-                // Constructor
-                cg.addln(&format!(
-                    "impl{} {}{} {{",
-                    generics.clone().get_rust(),
-                    name.clone().get_rust(),
-                    format!(
-                        "<{}>",
-                        generics
-                            .clone()
-                            .0
-                            .into_iter()
-                            .map(|v| Generic::from(v).get_rust())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    )
-                ));
-                cg.indent += 1;
-
-                let constructor_comment = constructor.get_comment();
-
-                cg.add_indentedln("#[allow(invalid_value)]");
-                cg.add_indentedln(&constructor_comment);
-
-                (fields, constructor).gen_rust(ctx, cg);
-
-                for item in items.clone() {
-                    match item {
-                        ClassItem::ImplDecl(_) => {}
-                        ClassItem::Method(method) => method.gen_rust(ctx, cg),
-                    }
-                }
-
-                cg.indent -= 1;
-                cg.addln("}\n");
-
-                for item in items {
-                    match item {
-                        ClassItem::ImplDecl(impl_) => {
-                            let mut impl_ = impl_.clone();
-
-                            impl_.item.trait_ = Some(impl_.item.target);
-                            impl_.item.target =
-                                TypeExpr(TypeExprKind::Path(Path(vec![name.clone()])), Vec::new());
-
-                            impl_.gen_rust(ctx, cg);
-                        }
-                        ClassItem::Method(_) => {}
-                    }
-                }
-
-                if let Some(inherits) = inherits {
-                    cg.add("impl std::ops::Deref for ");
-                    cg.add(&name.get_rust());
-
-                    cg.addln(" {");
-                    cg.indent += 1;
-
-                    cg.add_indented("type Target = ");
-                    cg.add(&inherits.get_rust());
-                    cg.addln(";");
-
-                    cg.add_indentedln("fn deref(&self) -> &Self::Target {&self._super}");
-
-                    cg.indent -= 1;
-                    cg.addln("}");
-
-                    // Mut
-
-                    cg.add("impl std::ops::DerefMut for ");
-                    cg.add(&name.get_rust());
-
-                    cg.addln(" {");
-                    cg.indent += 1;
-
-                    cg.add_indentedln(
-                        "fn deref_mut(&mut self) -> &mut Self::Target {&mut self._super}",
-                    );
-
-                    cg.indent -= 1;
-                    cg.addln("}");
-                }
-            }
+            } => class_decl::class_decl(
+                ctx,
+                cg,
+                visibility,
+                name,
+                generics,
+                inherits,
+                fields,
+                constructor,
+                items,
+            ),
         }
     }
 }

crates/mist-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mist-api"
-version = "0.1.7-alpha.1"
+version = "0.3.7-alpha.0"
 edition = "2024"
 description = "The Mist programming language module system"
 license = "Apache-2.0"
@@ -20,6 +20,7 @@ serde_json = "1.0.149"
 cargo_metadata = "0.23.1"
 mist-parser = { workspace = true }
 mist-codegen = { workspace = true }
+toml = "1.1.2"
 
 [lib]
 name = "mist_api"

crates/mist-api/Mist.toml

@@ -0,0 +1,2 @@
+package = "lib.mist"
+packages = []

crates/mist-api/src/builder.mist

@@ -1,20 +1,21 @@
-use std::{
-    collections::HashMap,
-    env, fs,
-    path::{MAIN_SEPARATOR, PathBuf},
-    process::{Command, Stdio},
-};
+pub module builder;
 
-use cargo_metadata::{CompilerMessage, Message};
-use mist_parser::rev_mapper::{RustMap, find_mapping, get_mapping};
+use std::collections::HashMap;
+use std::fs;
+use std::path::PathBuf;
+use std::process::Command;
+use std::process::Stdio;
+use cargo_metadata::CompilerMessage;
+use cargo_metadata::Message;
+use mist_parser::rev_mapper;
 
 #[derive(Debug, Clone)]
 pub struct MistDiagnosticMessage {
-    pub message: String,
-    pub file_path: PathBuf,
-    pub file_name: String,
-    pub line: usize,
-    pub column: usize,
+    pub String message,
+    pub PathBuf file_path,
+    pub String file_name,
+    pub usize line,
+    pub usize column,
 }
 
 #[derive(Debug, Clone)]
@@ -24,12 +25,10 @@ pub enum MistDiagnostic {
     Rust(CompilerMessage),
 }
 
-pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
+pub bool build(Vec<String> mut args, PathBuf root) {
     args.remove(0);
     args.insert(1, "--message-format=json".to_string());
 
-    let is_root = root == env::current_dir().expect("Failed getting env");
-
     let mut command = Command::new("cargo")
         .args(args)
         .stdout(Stdio::piped())
@@ -44,8 +43,6 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
 
     let mut mapping = HashMap::new();
 
-    let mist_src = format!(".mist{MAIN_SEPARATOR}src");
-
     for message in cargo_metadata::Message::parse_stream(&mut reader) {
         match message {
             Ok(Message::CompilerMessage(msg)) => {
@@ -53,29 +50,23 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
                     if span.is_primary {
                         let rust_path = root.join(&span.file_name);
 
-                        let mist_file = span
-                            .file_name
-                            .replacen(&mist_src, "src", 1)
-                            .trim_end_matches(".rs")
-                            .to_string()
-                            + ".mist";
+                        let mapping_path = rust_path.with_extension("map.json");
 
-                        let mist_path = root.join(&mist_file);
-
-                        if !fs::exists(&mist_path).expect("Unable to check if mist file exists") {
+                        if !fs::exists(&mapping_path).expect("Unable to check if map file exists") {
                             diagnostics.push(MistDiagnostic::Rust(msg));
                             break;
                         }
 
-                        let map = mapping.entry(rust_path.clone()).or_insert_with(|| {
-                            get_mapping(
-                                &fs::read_to_string(rust_path)
-                                    .expect("Failed to read file for mapping"),
-                            )
+                        let map = mapping.entry(mapping_path.clone()).or_insert_with(() => {
+                            let map_str = fs::read_to_string(mapping_path).expect("Failed to read map file");
+
+                            serde_json::from_str<rev_mapper::Mapping>(&map_str).expect("Failed to parse map file")
                         });
 
-                        let mist_span =
-                            find_mapping(&map, &RustMap(span.line_end, span.column_start))
+                        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 mist_msg = MistDiagnosticMessage {
@@ -84,14 +75,14 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
                                 msg.message.message,
                                 span.label.clone().unwrap_or_default()
                             ),
-                            file_name: if is_root {
-                                mist_file
+                            file_name: if let Ok(mist_file) = mist_file {
+                                mist_file.to_string_lossy().to_string()
                             } else {
-                                mist_path.to_string_lossy().to_string()
+                                map.mist_path.to_string_lossy().to_string()
                             },
-                            file_path: mist_path,
-                            line: mist_span.1.0,
-                            column: mist_span.1.1,
+                            file_path: map.mist_path.clone(),
+                            line: line,
+                            column: column
                         };
 
                         match msg.message.level {
@@ -116,7 +107,7 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
                 let mut stdout = std::io::stdout();
 
                 std::io::copy(&mut raw_reader, &mut stdout)
-                    .map_err(|v| v.to_string())
+                    .map_err((v) => v.to_string())
                     .expect("(Mist) Failed to copy IO");
 
                 command.wait().unwrap();
@@ -124,7 +115,7 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
                 return finish.success;
             }
 
-            Ok(Message::TextLine(text)) => println!("{text}"),
+            Ok(Message::TextLine(text)) => println!("{text}");
             _ => {}
         }
     }
@@ -132,7 +123,7 @@ pub fn build(mut args: Vec<String>, root: PathBuf) -> bool {
     false
 }
 
-pub fn print_diagnostics(diagnostics: &Vec<MistDiagnostic>) {
+pub void print_diagnostics(Vec<MistDiagnostic>& diagnostics) {
     let mut files = HashMap::new();
 
     for diag in diagnostics {
@@ -163,18 +154,18 @@ pub fn print_diagnostics(diagnostics: &Vec<MistDiagnostic>) {
                 )
             }
 
-            MistDiagnostic::Rust(rs) => println!("{rs}"),
+            MistDiagnostic::Rust(rs) => println!("{rs}");
         }
     }
 }
 
-pub fn get_line(
-    files: &mut HashMap<PathBuf, Vec<String>>,
-    msg: &MistDiagnosticMessage,
-) -> Option<String> {
+pub Option<String> get_line(
+    HashMap<PathBuf, Vec<String>> mut& files,
+    MistDiagnosticMessage& msg,
+) {
     let src_path = msg.file_path.clone();
 
-    let lines = files.entry(src_path.clone()).or_insert_with(|| {
+    let lines = files.entry(src_path.clone()).or_insert_with(() => {
         fs::read_to_string(src_path)
             .expect("Unable to read mist file")
             .lines()
@@ -183,5 +174,5 @@ pub fn get_line(
             .collect()
     });
 
-    lines.get(msg.line - 1).map(|v| v.trim().to_string())
+    lines.get(msg.line - 1).map((v) => v.trim().to_string())
 }

crates/mist-api/src/lib.mist

@@ -1,3 +0,0 @@
-pub mod builder;
-pub mod transpiler;
-pub mod modules;

crates/mist-api/src/main.mist

@@ -1,5 +0,0 @@
-pub mod builder;
-pub mod transpiler;
-pub mod modules;
-
-void main() {}

crates/mist-api/src/modules.mist

@@ -1,117 +1,99 @@
-use <std::path::Path>;
-use <std::path::PathBuf>;
-use <std::fs>;
-use <std::process>;
+pub module modules;
+
+use std::path::Path;
+use std::path::PathBuf;
+use std::fs;
+use std::process;
+
+use crate::transpiler::MistConfig;
 
 #[derive(Debug)]
 pub class Module {
     pub String name;
     pub PathBuf path;
-    pub Vec<Self> children;
+    pub Vec<Module> children;
 
-    pub constructor(String name, PathBuf mist_path, PathBuf rust_path) {
-        self.children = new Vec();
-        self.name = name;
+    pub constructor(PathBuf mist_path, MistConfig& config) {
+        self.children = Vec::new();
+        self.name = mist_path.file_stem()
+            .and_then((s) => s.to_str())
+            .expect("Failed to get module name")
+            .to_string();
         self.path = mist_path;
 
-        if (self.path.is_dir()) {
-            PathBuf dir = self.path.clone();
+        if self.path.is_dir() {
+            let dir = self.path.clone();
 
-            // Behavior 2: It's a directory node. Check for gateway package.mist first.
-            PathBuf pkg_gate = self.path.join("package.mist");
-            if (pkg_gate.exists()) {
+            let pkg_gate = self.path.join("package.mist");
+            if pkg_gate.exists() {
                 self.path = pkg_gate;
             }
 
-            self.scan_directory(&dir, &rust_path);
+            self.scan_directory(&dir, config);
+        } else if config.should_ignore(&self.path) {
+            let dir = self.path.parent().expect("Failed to get parent directory to scan").to_path_buf();
+
+            self.scan_directory(&dir, config);
         }
     }
 
-    void scan_directory(self mut*, Path* search_dir, Path* rust_path) {
-        var entries = match (fs::read_dir(search_dir)) {
-            Ok[entries] => entries;
-            Err[e] => {
+    void scan_directory(&mut self, Path& search_dir, MistConfig& config) {
+        let entries = match fs::read_dir(search_dir) {
+            Ok(entries) => entries;
+            Err(e) => {
                 eprintln!("error: failed to read directory {}\n  {}", search_dir.display(), e);
                 process::exit(1);
             }
         };
 
-        for (entry : entries) {
-            var entry = match (entry) {
-                Ok[entry] => entry;
-                Err[e] => {
+        for entry in entries {
+            let entry = match entry {
+                Ok(entry) => entry;
+                Err(e) => {
                     eprintln!("error: failed to read directory entry\n  {}", e);
                     process::exit(1);
                 }
             };
 
-            PathBuf child_path = entry.path();
+            let child_path = entry.path();
 
-            if (child_path == self.path) {
+            if child_path == self.path || child_path == config.package {
                 continue;
             }
 
-            String child_name = child_path.file_stem()
-                .and_then(|var s| s.to_str())
-                .expect("Failed to get module name")
-                .to_string();
-
-            PathBuf child_output = rust_path.join(&child_name).with_extension("rs");
-
-            if (!child_path.is_dir() && should_skip(&child_path, &child_output)) {
-                continue;
-            }
-
-            self.children.push(new Module(child_name, child_path, child_output));
+            self.children.push(Module::new(child_path, config));
         }
     }
 
-    pub PathBuf output_dir(self*, PathBuf* parent_dir) {
-        if (self.path.is_dir() || Some("package.mist") == self.path.file_name().unwrap().to_str()) {
+    pub bool is_package(&self) {
+        self.path.file_name().map((v) => v.to_str()).unwrap_or_default() == Some("package.mist")
+    }
+
+    pub PathBuf output_dir(&self, PathBuf& parent_dir) {
+        if self.path.is_dir() || self.is_package() {
             parent_dir.join(&self.name)
         } else {
             parent_dir.clone()
         }
     }
 
-    pub PathBuf output_path(self*, PathBuf* parent_dir) {
-        if (self.path.is_dir() || Some("package.mist") == self.path.file_name().unwrap().to_str()) {
-            parent_dir.join(&self.name).join("mod.rs")
+    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 {
+            &name.0
         } else {
-            parent_dir.join(&self.name).with_extension("rs")
+            &self.name
+        };
+
+        if self.path.is_dir() || self.is_package() {
+            parent_dir.join(name).join("mod.rs")
+        } else {
+            parent_dir.join(name).with_extension("rs")
         }
     }
 }
-
-pub Module master_package(PathBuf mist_path, PathBuf rust_path) {
-    String name = mist_path.file_stem()
-        .and_then(|var s| s.to_str())
-        .expect("Failed to get module name")
-        .to_string();
-
-    var mut root_mod = new Module(name, mist_path.clone(), rust_path.clone());
-
-    if (!mist_path.is_dir()) {
-        PathBuf parent_dir = mist_path.parent()
-            .expect("Failed to get parent directory of root file")
-            .to_path_buf();
-            
-        root_mod.scan_directory(&parent_dir, &rust_path);
-    }
-
-    root_mod
-}
-
-bool should_skip(Path* source, Path* output) {
-    var src_time = fs::metadata(source)
-        .ok()
-        .and_then(|var v| v.modified().ok());
-
-    var out_time = fs::metadata(output)
-        .ok()
-        .and_then(|var v| v.modified().ok());
-
-    out_time
-        .map(|var out_time| out_time >= src_time.unwrap())
-        .unwrap_or_default()
-}

crates/mist-api/src/transpiler.mist

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

crates/parser/Cargo.toml

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

crates/parser/src/ast/expr.rs

@@ -7,6 +7,13 @@ pub enum Expression {
     Literal(Literal),
     Path(ExprPath),
     Statement(Box<Statement>),
+    Array(Vec<Expression>),
+    ArrayRepeat(Box<Expression>, Box<Expression>),
+    Closure {
+        return_type: Option<TypeExpr>,
+        params: Vec<VarDecl>,
+        body: Box<Expression>,
+    },
     Fix {
         initial: Box<Expression>,
         prefixes: Vec<Prefix>,
@@ -26,26 +33,35 @@ pub enum Literal {
     Float(f64),
     Bool(bool),
     Tuple(Vec<Expression>),
-    Array(Vec<Expression>),
-    ArrayRepeat(Box<Expression>, Box<Expression>),
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Pattern {
     NamedTuple(Path, Vec<Box<Pattern>>),
-    Struct(Path, Vec<Box<Pattern>>),
+    Struct(Path, Vec<Option<(Identifier, Option<Box<Pattern>>)>>),
     Tuple(Vec<Box<Pattern>>),
     Literal(Literal),
     Path(bool, Path),
+    Etc,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub enum MacroDelimiter {
+    Paren,
+    Bracket,
+    Brace,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Postfix {
     FieldAccess(Identifier, Option<Generics>),
+    TupleFieldAccess(u8, Option<Generics>),
     Call(Vec<Expression>),
-    MacroCall(String),
-    StructCall(Vec<(Identifier, Expression)>),
-    Assign(String, Box<Expression>),
+    MacroCall {
+        inner: String,
+        delimiter: MacroDelimiter,
+    },
+    StructCall(Vec<(Identifier, Option<Expression>)>),
     Index(Expression),
     As(TypeExpr),
     Increment,
@@ -58,25 +74,23 @@ pub enum Prefix {
     Ref,
     RefMut,
     Deref,
-    New(Option<Generics>),
     Not,
     Neg,
-    Closure(Option<TypeExpr>, Vec<VarDecl>),
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub struct ExprPathSegment {
     pub ident: Identifier,
     pub generics: Option<Generics>,
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub struct ExprPath(pub Vec<ExprPathSegment>);
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub struct Generics(pub Vec<Generic>);
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub enum Generic {
     Lifetime(Identifier),
     Type(TypeExpr),
@@ -91,3 +105,17 @@ impl Expression {
         }
     }
 }
+
+impl From<Path> for ExprPath {
+    fn from(path: Path) -> Self {
+        Self(
+            path.0
+                .into_iter()
+                .map(|v| ExprPathSegment {
+                    ident: v,
+                    generics: None,
+                })
+                .collect(),
+        )
+    }
+}

crates/parser/src/ast/mod.rs

@@ -8,33 +8,46 @@ pub use expr::*;
 pub use statement::*;
 pub use top_level::*;
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub struct Path(pub Vec<Identifier>);
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
 pub struct Identifier(pub String);
 
 #[derive(Debug, Clone, Serialize, Default)]
 pub struct ParamList(pub Vec<VarDecl>);
 
-#[derive(Debug, Clone, Serialize)]
-pub struct TypeExpr(pub TypeExprKind, pub Vec<TypePostfix>);
-
-#[derive(Debug, Clone, Serialize)]
-pub enum TypePostfix {
-    Ref,
-    RefMut,
-    RefLifetime(Identifier),
-    RefMutLifetime(Identifier),
-    Dyn,
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
+pub enum FnKind {
+    Fn,
+    UnsafeFn,
+    FnClosure,
+    FnOnce,
+    FnMut,
 }
 
-#[derive(Debug, Clone, Serialize)]
-pub enum TypeExprKind {
-    Path(Path),
-    PathParams(Path, Vec<TypeExpr>),
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
+pub enum TypeExpr {
+    Ref {
+        lifetime: Option<Identifier>,
+        mutable: bool,
+        ty: Box<TypeExpr>,
+    },
+    UnsafePtr {
+        mutable: bool,
+        ty: Box<TypeExpr>,
+    },
+    Dyn(Box<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>,
+    },
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -44,25 +57,27 @@ pub struct Spanned<T> {
     pub item: T,
 }
 
-impl TypeExpr {
-    pub fn no_px(kind: TypeExprKind) -> Self {
-        Self(kind, Vec::new())
-    }
-}
-
 impl From<GenericDecl> for Generic {
     fn from(value: GenericDecl) -> Self {
         match value {
             GenericDecl::Lifetime(life) => Generic::Lifetime(life),
-            GenericDecl::Type(ty, _) => {
-                Generic::Type(TypeExpr(TypeExprKind::Path(Path(vec![ty])), Vec::new()))
-            }
+            GenericDecl::Type(ty, _) => Generic::Type(TypeExpr::Path(Path(vec![ty]), None)),
         }
     }
 }
 
-impl<T> Spanned<T> {
-    pub fn get_comment(&self) -> String {
-        format!("/* {}:{} */", self.line, self.column)
+impl Into<Option<Generics>> for GenericsDecl {
+    fn into(self) -> Option<Generics> {
+        if self.0.len() == 0 {
+            None
+        } else {
+            Some(self.into())
+        }
+    }
+}
+
+impl From<GenericsDecl> for Generics {
+    fn from(value: GenericsDecl) -> Self {
+        Self(value.0.into_iter().map(Generic::from).collect())
     }
 }

crates/parser/src/ast/statement.rs

@@ -3,37 +3,32 @@ use serde::Serialize;
 use super::*;
 
 #[derive(Debug, Clone, Serialize, Default)]
-pub struct Block(
-    pub Vec<Spanned<Expression>>,
-    pub Option<Spanned<Expression>>,
-);
-
-#[derive(Debug, Clone, Serialize)]
-pub enum StatementBody {
-    Statement(Expression),
-    Expression(Expression),
+pub struct Block {
+    pub statements: Vec<Spanned<Expression>>,
+    pub soft_return: Option<Spanned<Expression>>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Statement {
+    UnsafeBlock(Block),
     Block(Block),
     If {
         initial: StatementBranch,
         else_if: Vec<StatementBranch>,
-        else_branch: Option<StatementBody>,
+        else_branch: Option<Block>,
     },
-    Loop(StatementBody),
+    Loop(Block),
     While(StatementBranch),
     CStyleFor {
         init: Expression,
         condition: Expression,
         update: Expression,
-        body: StatementBody,
+        body: Block,
     },
     For {
         pattern: Pattern,
         iterator: Expression,
-        body: StatementBody,
+        body: Block,
     },
     Match(Expression, Vec<Spanned<MatchItem>>),
 
@@ -61,29 +56,14 @@ pub struct VarDeclStmt {
 #[derive(Debug, Clone, Serialize)]
 pub struct StatementBranch {
     pub condition: Expression,
-    pub body: Box<StatementBody>,
+    pub body: Box<Block>,
 }
 
 impl Statement {
     pub fn is_block(&self) -> bool {
         match self {
-            Self::Block(_)
-            | Self::Match(_, _)
-            | Self::While(_)
-            | Self::For { .. }
-            | Self::Loop(..)
-            | Self::CStyleFor { .. }
-            | Self::If { .. } => true,
-            _ => false,
-        }
-    }
-}
-
-impl StatementBody {
-    pub fn is_soft_return(&self) -> bool {
-        match self {
-            Self::Expression(_) => true,
-            _ => false,
+            Self::VarDecl(_) | Self::Return(_) | Self::Break | Self::Continue => false,
+            _ => true,
         }
     }
 }

crates/parser/src/ast/top_level.rs

@@ -28,7 +28,7 @@ pub struct TopLevel(pub Spanned<TopLevelKind>, pub Vec<Attribute>);
 pub enum TopLevelKind {
     ModAttribute,
     Import(Visibility, Path),
-    Mod(Visibility, Identifier),
+    DeclareModule(Visibility, Identifier),
     ImplDecl(ImplDecl),
     TraitDecl {
         visibility: Visibility,
@@ -54,9 +54,9 @@ pub enum TopLevelKind {
         visibility: Visibility,
         name: Identifier,
         generics: GenericsDecl,
-        inherits: Option<TypeExpr>,
+        inherits: Option<ExprPath>,
         fields: Vec<Spanned<FieldDeclStmt>>,
-        constructor: Spanned<ClassConstructor>,
+        constructor: Option<Spanned<ClassConstructor>>,
         items: Vec<ClassItem>,
     },
 }
@@ -91,13 +91,18 @@ pub struct ClassConstructor {
     pub body: Block,
 }
 
+#[derive(Debug, Clone, Serialize, PartialEq, Eq, Hash)]
+pub struct Override(pub Option<ExprPath>);
+
 #[derive(Debug, Clone, Serialize)]
 pub struct FunctionDecl {
     pub visibility: Visibility,
+    pub is_override: Option<Override>,
     pub name: Identifier,
     pub generics: GenericsDecl,
+    pub self_param: Option<(bool, Option<Identifier>, bool)>,
     pub params: ParamList,
-    pub return_type: TypeExpr,
+    pub return_type: Option<TypeExpr>,
     pub body: Option<Block>,
 }
 

crates/parser/src/error.rs

@@ -4,52 +4,43 @@ use pest::iterators::Pair;
 
 use crate::Rule;
 
-pub type AstResult<'a, T, ET = T> = Result<T, AstError<'a, ET>>;
+pub type AstResult<'a, T> = Result<T, AstError<'a>>;
 
 #[derive(Debug, Clone)]
-pub enum ParseError<'a, T> {
+pub enum ParseError<'a> {
     PreAst(pest::error::Error<Rule>),
-    Ast(AstError<'a, T>),
+    Ast(AstError<'a>),
 }
 
 #[derive(Debug, Clone)]
-pub struct AstError<'a, T> {
+pub struct AstError<'a> {
     pub span: pest::Span<'a>,
     pub error_code: ErrorCode,
     pub error_message: String,
-    pub recovered: Option<T>,
 }
 
 #[derive(Debug, Clone)]
 pub enum ErrorCode {
     InvalidStatement,
     AstGenBug,
+    Module,
 }
 
-impl<T> From<pest::error::Error<Rule>> for ParseError<'_, T> {
+impl From<pest::error::Error<Rule>> for ParseError<'_> {
     fn from(value: pest::error::Error<Rule>) -> Self {
         Self::PreAst(value)
     }
 }
 
-impl<'a, T> From<AstError<'a, T>> for ParseError<'a, T> {
-    fn from(value: AstError<'a, T>) -> Self {
+impl<'a> From<AstError<'a>> for ParseError<'a> {
+    fn from(value: AstError<'a>) -> Self {
         Self::Ast(value)
     }
 }
 
-impl<'a, F> AstError<'a, F> {
-    pub fn get<T>(self) -> AstError<'a, T> {
-        AstError {
-            span: self.span,
-            error_code: self.error_code,
-            error_message: self.error_message,
-            recovered: None,
-        }
-    }
-
+impl<'a> AstError<'a> {
     #[track_caller]
-    pub fn bug_unimplemented<T>(pair: Pair<'a, Rule>) -> AstResult<'a, T, F> {
+    pub fn bug_unimplemented<T>(pair: Pair<'a, Rule>) -> AstResult<'a, T> {
         let loc = std::panic::Location::caller();
 
         Err(Self {
@@ -61,7 +52,6 @@ impl<'a, F> AstError<'a, F> {
                 loc.file(),
                 loc.line(),
             ),
-            recovered: None,
         })
     }
 }
@@ -71,21 +61,6 @@ pub trait IntoErr<T, FA, FR> {
     fn get_map(self, m: impl Fn(FA) -> FR) -> T;
 }
 
-impl<'a, T, TE, TE2> IntoErr<AstResult<'a, T, TE2>, TE, TE2> for AstResult<'a, T, TE> {
-    fn get(self) -> AstResult<'a, T, TE2> {
-        self.map_err(AstError::get)
-    }
-
-    fn get_map(self, m: impl Fn(TE) -> TE2) -> AstResult<'a, T, TE2> {
-        self.map_err(|e| AstError {
-            span: e.span,
-            error_code: e.error_code,
-            error_message: e.error_message,
-            recovered: e.recovered.map(m),
-        })
-    }
-}
-
 pub trait GetLength {
     fn len(&self) -> usize;
 }
@@ -96,24 +71,24 @@ impl<T, E> GetLength for Result<Vec<T>, E> {
     }
 }
 
-pub fn collect_recovered<'a, T: Debug, ET>(
+pub fn collect_recovered<'a, T: Debug>(
     pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
-) -> AstResult<'a, Vec<T>, Vec<T>>
+) -> AstResult<'a, Vec<T>>
 where
-    T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a, ET>>,
+    T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a>>,
 {
     collect_recovered_map(pairs, T::try_from)
 }
 
-pub fn collect_recovered_map<'a, T: Debug, F, ET>(
+pub fn collect_recovered_map<'a, T: Debug, F>(
     pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
     f: F,
-) -> AstResult<'a, Vec<T>, Vec<T>>
+) -> AstResult<'a, Vec<T>>
 where
-    F: Fn(pest::iterators::Pair<'a, Rule>) -> AstResult<'a, T, ET>,
+    F: Fn(pest::iterators::Pair<'a, Rule>) -> AstResult<'a, T>,
 {
     let mut items = Vec::new();
-    let mut last_error: Option<AstError<'a, ET>> = None;
+    let mut last_error: Option<AstError<'a>> = None;
 
     for pair in pairs {
         match f(pair) {
@@ -129,39 +104,7 @@ where
             span: ast_err.span,
             error_code: ast_err.error_code,
             error_message: ast_err.error_message,
-            recovered: Some(items),
         }),
         None => Ok(items),
     }
 }
-
-pub struct AstErrorAnalyzer<'a, T>(pub Option<AstError<'a, T>>);
-
-impl<'a, T> AstErrorAnalyzer<'a, T> {
-    pub fn get<V: Clone, V2: Clone + Into<V>>(
-        &mut self,
-        r: AstResult<'a, V, V2>,
-    ) -> AstResult<'a, V, V2> {
-        if let Err(e) = r {
-            self.0 = Some(e.clone().get());
-
-            if let Some(recovered) = e.recovered {
-                Ok(recovered.into())
-            } else {
-                Err(e)
-            }
-        } else {
-            r
-        }
-    }
-
-    pub fn build(self, v: T) -> AstResult<'a, T> {
-        if let Some(mut e) = self.0 {
-            e.recovered = Some(v);
-
-            Err(e)
-        } else {
-            Ok(v)
-        }
-    }
-}

crates/parser/src/grammar.pest

@@ -12,6 +12,7 @@ COMMENT    = _{ "//" ~ (!"\n" ~ ANY)* }
 keyword = {
     "if"
   | "else"
+  | "fn"
   | "for"
   | "while"
   | "match"
@@ -25,11 +26,13 @@ keyword = {
   | "impl"
   | "pub"
   | "mut"
-  | "var"
+  | "let"
   | "true"
   | "false"
   | "dyn"
   | "loop"
+  | "unsafe"
+  | "override"
 }
 
 identifier = @{
@@ -69,21 +72,24 @@ program = {
     SOI ~ top_level* ~ EOI
 }
 
+module_program = {
+    SOI ~ top_level?
+}
+
 // ======================================================
 // MODIFIERS
 // ======================================================
 
 visibility = { "pub" ~ ("(" ~ static_path ~ ")")? }
 mutable    = { "mut" }
-var        = { "var" }
 
 // ======================================================
 // GENERICS
 // ======================================================
-generic_decl  = { lifetime | (identifier ~ (":" ~ type_expr_param ~ ("+" ~ type_expr_param)*)?) }
+generic_decl  = { lifetime | (identifier ~ (":" ~ generic ~ ("+" ~ generic)*)?) }
 generics_decl = { "<" ~ (generic_decl ~ ("," ~ generic_decl)*)? ~ ">" }
 
-generic  = { lifetime | type_expr_param }
+generic  = { lifetime | type_expr }
 generics = { "<" ~ (generic ~ ("," ~ generic)*)? ~ ">" }
 
 // ======================================================
@@ -91,34 +97,55 @@ generics = { "<" ~ (generic ~ ("," ~ generic)*)? ~ ">" }
 // ======================================================
 
 tuple_type = {
-    "[" ~ (type_expr ~ ("," ~ type_expr)*)? ~ "]"
+    "(" ~ (type_expr ~ ("," ~ type_expr)*)? ~ ","? ~ ")"
 }
 
 path_type = {
-    static_path ~ ("<" ~ (type_expr_param ~ ("," ~ type_expr_param)*)? ~ ">")?
+    static_path ~ generics?
+}
+
+unsafe_ref_type = {
+    mutable? ~ "unsafe" ~ "*"
 }
 
 ref_type = {
-    mutable? ~ lifetime? ~ "*"
+    mutable? ~ lifetime? ~ "&"
+}
+
+fn_kind_fn      = { "fn" }
+fn_kind_unsafe  = { "unsafe" ~ "fn" }
+fn_kind_closure = { "Fn" }
+fn_kind_once    = { "FnOnce" }
+fn_kind_mut     = { "FnMut" }
+
+fn_kind = _{
+    fn_kind_fn
+  | fn_kind_unsafe
+  | fn_kind_closure
+  | fn_kind_once
+  | fn_kind_mut
+}
+
+fn_type = {
+    fn_kind ~ "(" ~ (type_expr ~ ("," ~ type_expr)*)? ~ ")"
 }
 
 dyn_type = {
-    "dyn"
+    "dyn" ~ type_expr
+}
+
+void_type = {
+    "void"
 }
 
 type_expr = {
-    (path_type | tuple_type) ~ (ref_type | dyn_type)*
+    (void_type | path_type | tuple_type | dyn_type) ~ (unsafe_ref_type | ref_type | fn_type)*
 }
 
 lifetime = {
     "'" ~ identifier
 }
 
-type_expr_param = {
-    type_expr
-  | lifetime
-}
-
 // ======================================================
 // LITERALS
 // ======================================================
@@ -134,20 +161,26 @@ literal = {
 // PATTERNS
 // ======================================================
 
+etc_pattern = { ".." }
+
 multi_pat_template = _{
-    (pattern ~ ("," ~ pattern)*)?
+    ((pattern | etc_pattern) ~ ("," ~ (pattern | etc_pattern))* ~ ","?)?
 }
 
 tuple_pattern = {
-    "[" ~ multi_pat_template ~ "]"
+    "(" ~ (pattern | etc_pattern) ~ "," ~ multi_pat_template ~ ")"
 }
 
 named_tuple_pattern = {
-    static_path ~ "[" ~ multi_pat_template ~ "]"
+    static_path ~ "(" ~ multi_pat_template ~ ")"
+}
+
+struct_destruct = {
+    identifier ~ (":" ~ pattern)?
 }
 
 struct_pattern = {
-    static_path ~ "{" ~ multi_pat_template ~ "}"
+    static_path ~ "{" ~ ((struct_destruct | etc_pattern) ~ ("," ~ (struct_destruct | etc_pattern))*)? ~ "}"
 }
 
 path_pattern = {
@@ -190,19 +223,25 @@ attributes = {
 // DECLARATION HELPERS
 // ======================================================
 var_decl = {
-    (var | type_expr) ~ pattern
+    ("let" ~ pattern)
+  | type_expr ~ (!tuple_pattern ~ pattern)
 }
 
 field = {
     visibility? ~ type_expr ~ identifier
 }
 
+param = {
+    (type_expr ~ pattern)
+  | pattern
+}
+
 field_list = {
     (field ~ ("," ~ field)* ~ ","?)?
 }
 
 param_list = {
-    (var_decl ~ ("," ~ var_decl)* ~ ","?)?
+    (param ~ ("," ~ param)* ~ ","?)?
 }
 
 // ======================================================
@@ -210,11 +249,11 @@ param_list = {
 // ======================================================
 
 import = {
-    visibility? ~ "use" ~ "<" ~ static_path ~ ">" ~ semicolon
+    visibility? ~ "use" ~ static_path ~ semicolon
 }
 
-mod_package = {
-    visibility? ~ "mod" ~ identifier ~ semicolon
+declare_module = {
+    visibility? ~ "module" ~ identifier ~ semicolon
 }
 
 // ======================================================
@@ -252,7 +291,7 @@ enum_fields = _{
 }
 
 enum_decl = {
-    visibility? ~ "enum" ~ identifier ~ generics_decl? ~ "{" ~ enum_fields ~ "}"
+    visibility? ~ "enum" ~ identifier ~ generics_decl? ~ "{" ~ enum_fields? ~ "}"
 }
 
 // ======================================================
@@ -272,45 +311,40 @@ class_field = {
 }
 
 self_param = {
-    "self" ~ mutable? ~ deref_px?
+    (ref_px ~ lifetime?)? ~ mutable? ~ "self"
 }
 
-method = {
-    visibility? ~ type_expr ~ identifier ~ generics_decl? ~ "(" ~ self_param? ~ ("," ~ param_list)? ~ ")" ~ block
+method_args = _{
+    ((self_param ~ ("," ~ param_list)?) | param_list) ~ ","?
 }
 
 class_item = _{
     impl_decl
-  | method
+  | function_decl
 }
 
 class_decl = {
-    visibility? ~ "class" ~ identifier ~ generics_decl? ~ (":" ~ type_expr)? ~ "{" ~ class_fields ~ class_constructor ~ class_item* ~ "}"
+    visibility? ~ "class" ~ identifier ~ generics_decl? ~ (":" ~ expr_path)? ~ "{" ~ class_fields ~ class_constructor? ~ class_item* ~ "}"
 }
 
 // ======================================================
 // IMPL
 // ======================================================
 impl_for_decl = {
-    "impl" ~ generics_decl? ~ type_expr ~ "for" ~ type_expr ~ "{" ~ method* ~ "}"
+    "impl" ~ generics_decl? ~ type_expr ~ "for" ~ type_expr ~ "{" ~ function_decl* ~ "}"
 }
 
 impl_decl = {
-    "impl" ~ generics_decl? ~ type_expr ~ "{" ~ method* ~ "}"
+    "impl" ~ generics_decl? ~ type_expr ~ "{" ~ function_decl* ~ "}"
 }
 
 // ======================================================
 // Traits
 // ======================================================
-trait_requirements = { ":" ~ type_expr_param ~ ("+" ~ type_expr_param)* }
-
-method_no_body = {
-    visibility? ~ type_expr ~ identifier ~ generics_decl? ~ "(" ~ self_param? ~ ("," ~ param_list)? ~ ")" ~ semicolon
-}
+trait_requirements = { ":" ~ generic ~ ("+" ~ generic)* }
 
 trait_item = _{
-    method
-  | method_no_body
+    function_decl
 }
 
 trait_decl = {
@@ -321,8 +355,10 @@ trait_decl = {
 // FUNCTIONS
 // ======================================================
 
+override_kw = { "override" ~ ("(" ~ expr_path ~ ")")? }
+
 function_decl = {
-    visibility? ~ type_expr ~ identifier ~ "(" ~ param_list ~ ")" ~ block
+    visibility? ~ ("void" | type_expr) ~ identifier ~ generics_decl? ~ "(" ~ method_args ~ ")" ~ override_kw? ~ (block | semicolon)
 }
 
 // ======================================================
@@ -330,8 +366,8 @@ function_decl = {
 // ======================================================
 
 top_level = {
-    (attributes ~ (import | impl_for_decl | impl_decl | trait_decl | struct_decl | enum_decl | class_decl | mod_package | function_decl))
-  | mod_attribute
+    mod_attribute
+  | (attributes ~ (import | impl_for_decl | impl_decl | trait_decl | struct_decl | enum_decl | class_decl | declare_module | function_decl))
 }
 
 // ======================================================
@@ -342,6 +378,10 @@ block = {
     "{" ~ statement_list ~ expr? ~ "}"
 }
 
+unsafe_block = {
+    "unsafe" ~ block
+}
+
 statement_list = {
     statement*
 }
@@ -351,10 +391,6 @@ statement = _{
   | (expr ~ semicolon)
 }
 
-statement_wrapper = { statement }
-
-statement_body = { statement_wrapper | expr }
-
 // ------------------------------------------------------
 // BASIC STATEMENTS
 // ------------------------------------------------------
@@ -394,11 +430,12 @@ control_flow = {
   | match_stmt
   | loop_stmt
   | block
+  | unsafe_block
 }
 
-statement_branch = { "(" ~ expr ~ ")" ~ statement_body }
+statement_branch = { (expr_no_struct | ("(" ~ expr ~ ")")) ~ block }
 
-else_if = {
+else_if = _{
     "else" ~ "if" ~ statement_branch
 }
 
@@ -407,7 +444,7 @@ else_if_list = {
 }
 
 if_stmt = {
-    "if" ~ statement_branch ~ else_if_list ~ ("else" ~ statement_body)?
+    "if" ~ statement_branch ~ else_if_list ~ ("else" ~ block)?
 }
 
 // ------------------------------------------------------
@@ -419,15 +456,15 @@ while_stmt = {
 }
 
 c_for_stmt = {
-    "for" ~ "(" ~ statement ~ statement ~ expr ~ ")" ~ statement_body
+    "for" ~ "(" ~ statement ~ statement ~ expr ~ ")" ~ block
 }
 
 for_stmt = {
-    "for" ~ "(" ~ pattern ~ ":" ~ expr ~ ")" ~ statement_body
+    "for" ~ pattern ~ "in" ~ expr ~ block
 }
 
 loop_stmt = {
-    "loop" ~ statement_body
+    "loop" ~ block
 }
 
 // ------------------------------------------------------
@@ -437,11 +474,11 @@ loop_stmt = {
 pattern_list = { pattern ~ ("|" ~ pattern)* }
 
 match_item = {
-    pattern_list ~ "=>" ~ statement
+    pattern_list ~ "=>" ~ (block | (expr ~ ","))
 }
 
 match_stmt = {
-    "match" ~ "(" ~ expr ~ ")" ~ "{" ~ match_item* ~ "}"
+    "match" ~ (expr_no_struct | "(" ~ expr ~ ")") ~ "{" ~ match_item* ~ "}"
 }
 
 // ======================================================
@@ -452,20 +489,25 @@ match_stmt = {
 // CLOSURES
 // ------------------------------------------------------
 
-closure = { type_expr? ~ "|" ~ param_list ~ "|" }
+closure = {
+    ("(" ~ param_list ~ ")" ~ "=>" ~ expr)
+  | (type_expr ~ "(" ~ param_list ~ ")" ~ "=>" ~ expr)
+}
 
 // ------------------------------------------------------
 // TUPLES & ARRAYS
 // ------------------------------------------------------
 
 tuple = {
-    "(" ~ (expr ~ ("," ~ expr)*)? ~ ")"
+    "(" ~ (expr ~ ("," ~ expr)*)? ~ ","? ~ ")"
+}
+
+array_repeat = {
+    "[" ~ expr ~ ";" ~ expr ~ "]"
 }
 
 array = {
-    "[" ~ expr ~ ";" ~ expr ~ "]" // Repeat notation: [0; 10]
-
-  | "[" ~ (expr ~ ("," ~ expr)* ~ ","?)? ~ "]" // Standard elements initialization
+    "[" ~ (expr ~ ("," ~ expr)* ~ ","?)? ~ "]"
 }
 
 // ------------------------------------------------------
@@ -475,7 +517,9 @@ array = {
 macro_inner_v = @{
     string_lit
   | ("(" ~ macro_inner_v* ~ ")")
-  | (!("(" | ")") ~ ANY)
+  | ("[" ~ macro_inner_v* ~ "]")
+  | ("{" ~ macro_inner_v* ~ "}")
+  | (!("(" | ")" | "[" | "]" | "{" | "}") ~ ANY)
 }
 
 // ------------------------------------------------------
@@ -483,7 +527,7 @@ macro_inner_v = @{
 // ------------------------------------------------------
 
 expr_path_segment = {
-    identifier ~ ("::" ~ generics)?
+    identifier ~ generics?
 }
 
 expr_path = {
@@ -492,10 +536,12 @@ expr_path = {
 
 primary = {
     control_flow
+  | closure
   | basic_stmt
   | literal
   | expr_path
   | tuple
+  | array_repeat
   | array
 }
 
@@ -504,19 +550,23 @@ primary = {
 // ------------------------------------------------------
 
 field_px = {
-    "." ~ identifier ~ ("::" ~ generics)?
+    "." ~ identifier ~ generics?
+}
+
+tuple_field_px = {
+    "." ~ integer ~ generics?
 }
 
 call_px = {
     "(" ~ (expr ~ ("," ~ expr)*)? ~ ")"
 }
 
-macro_call_px = {
-    "!" ~ "(" ~ macro_inner_v* ~ ")"
-}
+macro_call_paren   = { "!" ~ "(" ~ macro_inner_v* ~ ")" }
+macro_call_bracket = { "!" ~ "[" ~ macro_inner_v* ~ "]" }
+macro_call_brace   = { "!" ~ "{" ~ macro_inner_v* ~ "}" }
 
 struct_field_decl = {
-    identifier ~ ":" ~ expr
+    identifier ~ (":" ~ expr)?
 }
 
 struct_px = {
@@ -545,8 +595,11 @@ decrement = {
 
 postfix = {
     field_px
+  | tuple_field_px
   | call_px
-  | macro_call_px
+  | macro_call_paren
+  | macro_call_bracket
+  | macro_call_brace
   | struct_px
   | index_px
   | as_px
@@ -562,16 +615,13 @@ postfix = {
 deref_px   = { "*" }
 mut_ref_px = { "&" ~ mutable }
 ref_px     = { "&" }
-new_px     = { "new" ~ generics? }
 not_px     = { "!" }
 neg_px     = { "-" }
 
 prefix = {
-    closure
-  | deref_px
+    deref_px
   | mut_ref_px
   | ref_px
-  | new_px
   | not_px
   | neg_px
 }
@@ -583,6 +633,7 @@ prefix = {
 bin_op = {
     "+="
   | "-="
+  | "*="
   | "/="
   | "%="
   | "&="
@@ -600,6 +651,7 @@ bin_op = {
   | "!="
   | "&&"
   | "||"
+  | "->"
   | "+"
   | "-"
   | "*"
@@ -620,3 +672,7 @@ bin_op = {
 expr = { term ~ (bin_op ~ term)* }
 
 term = { prefix* ~ primary ~ postfix* }
+
+expr_no_struct = { term_no_struct ~ (bin_op ~ term_no_struct)* }
+
+term_no_struct = { prefix* ~ primary ~ (!struct_px ~ postfix)* }

crates/parser/src/lib.rs

@@ -5,31 +5,67 @@ pub mod ast;
 pub mod error;
 pub mod parser;
 pub mod rev_mapper;
+pub mod semantics;
 
 use ast::*;
 
-use crate::error::{IntoErr, ParseError};
+use crate::error::ParseError;
 
 #[derive(Parser)]
 #[grammar = "./src/grammar.pest"]
 pub struct MistParser;
 
-pub fn parse<'a>(source: &'a str) -> Result<Vec<TopLevel>, ParseError<'a, Vec<TopLevel>>> {
+pub struct Program {
+    pub mod_attributes: Vec<TopLevel>,
+    pub items: Vec<TopLevel>,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct MistFmtConfig {
+    pub allman_bracket_style: bool,
+}
+
+pub fn parse<'a>(source: &'a str) -> Result<Program, ParseError<'a>> {
     let mut pairs = MistParser::parse(Rule::program, source)?;
 
     let mut statements = vec![];
 
-    let mut analyzer = error::AstErrorAnalyzer(None);
-
     for pair in pairs.next().unwrap().into_inner() {
         if pair.as_rule() != Rule::EOI {
-            statements.push(analyzer.get(TopLevel::try_from(pair)).get()?);
+            statements.push(TopLevel::try_from(pair)?);
         }
     }
 
-    match analyzer.build(statements) {
-        Ok(v) => Ok(v),
-        Err(e) => Err(ParseError::Ast(e)),
+    let (mod_attributes, items): (Vec<_>, Vec<_>) = statements
+        .into_iter()
+        .partition(|item| matches!(item.0.item, TopLevelKind::ModAttribute));
+
+    Ok(Program {
+        items,
+        mod_attributes,
+    })
+}
+
+pub fn parse_module<'a>(
+    source: &'a str,
+) -> Result<Option<(Visibility, Identifier)>, ParseError<'a>> {
+    let mut pairs = MistParser::parse(Rule::module_program, source)?;
+
+    if let Some(v) = pairs
+        .next()
+        .unwrap()
+        .into_inner()
+        .next()
+        .map(TopLevel::try_from)
+        .transpose()?
+    {
+        if let TopLevelKind::DeclareModule(vis, name) = &v.0.item {
+            Ok(Some((vis.clone(), name.clone())))
+        } else {
+            Ok(None)
+        }
+    } else {
+        Ok(None)
     }
 }
 
@@ -43,41 +79,7 @@ macro_rules! ast_ensure {
                 span: $pair.as_span(),
                 error_code: crate::error::ErrorCode::AstGenBug,
                 error_message: format!("Possible bug: expected {:?}, got {:?}", $rule, $pair.as_rule()),
-                recovered: None,
             })
         }
     };
 }
-
-#[macro_export]
-macro_rules! ast_expr {
-    (use $r:expr, $($v:expr),* $(,)?) => {{
-        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
-
-        $(
-            analyzer.get($v).get()?;
-        )*
-
-        analyzer.build($r)
-    }};
-
-    ($($item:ident)::+ { $($k:ident: $v:expr),* $(,)? }) => {{
-        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
-
-        let v = $($item)::+ { $($k: analyzer.get($v).get()?),* };
-
-        analyzer.build(v)
-    }};
-
-    ($($item:ident)::+ ( $($v:expr),* $(,)? )) => {{
-        let mut analyzer = $crate::error::AstErrorAnalyzer(None);
-
-        let v = $($item)::+ ( $(analyzer.get($v).get()?),* );
-
-        analyzer.build(v)
-    }};
-
-    ($($item:ident)::+) => {
-        $($item)::+
-    };
-}

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

@@ -1,21 +1,21 @@
 use crate::{
     Rule,
     ast::*,
-    ast_expr,
-    error::{AstError, IntoErr},
+    error::{AstError, collect_recovered},
+    parser::consume_rule,
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDeclStmt {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
             Rule::var_decl_statement => {
                 let mut inner = pair.into_inner();
 
-                ast_expr!(VarDeclStmt {
-                    decl: inner.next().unwrap().try_into(),
-                    init: inner.next().map(Expression::try_from).transpose()
+                Ok(VarDeclStmt {
+                    decl: inner.next().unwrap().try_into()?,
+                    init: inner.next().map(Expression::try_from).transpose()?,
                 })
             }
 
@@ -25,16 +25,16 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDeclStmt {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FieldDeclStmt {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
             Rule::class_field => {
                 let mut inner = pair.into_inner();
 
-                ast_expr!(FieldDeclStmt {
-                    decl: inner.next().unwrap().try_into(),
-                    init: inner.next().map(Expression::try_from).transpose(),
+                Ok(FieldDeclStmt {
+                    decl: inner.next().unwrap().try_into()?,
+                    init: inner.next().map(Expression::try_from).transpose()?,
                 })
             }
 
@@ -44,29 +44,18 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FieldDeclStmt {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
-            Rule::var_decl => {
+            Rule::var_decl | Rule::param => {
                 let mut inner = pair.into_inner();
 
-                let type_ = inner
-                    .next()
-                    .and_then(|pair| {
-                        if pair.as_str().trim() == "var" {
-                            None
-                        } else {
-                            Some(TypeExpr::try_from(pair))
-                        }
-                    })
-                    .transpose();
-
-                let name = Pattern::try_from(inner.next().unwrap());
-
-                ast_expr!(VarDecl {
-                    type_: type_,
-                    name: name,
+                Ok(VarDecl {
+                    type_: consume_rule(&mut inner, Rule::type_expr)
+                        .map(TypeExpr::try_from)
+                        .transpose()?,
+                    name: Pattern::try_from(inner.next().unwrap())?,
                 })
             }
 
@@ -76,17 +65,17 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for VarDecl {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FieldDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
             Rule::field => {
                 let mut inner = pair.into_inner();
 
-                ast_expr!(FieldDecl {
-                    visibility: Visibility::try_from(&mut inner),
-                    type_: TypeExpr::try_from(inner.next().unwrap()),
-                    name: Identifier::try_from(inner.next().unwrap()),
+                Ok(FieldDecl {
+                    visibility: Visibility::try_from(&mut inner)?,
+                    type_: TypeExpr::try_from(inner.next().unwrap())?,
+                    name: Identifier::try_from(inner.next().unwrap())?,
                 })
             }
 
@@ -94,3 +83,11 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FieldDecl {
         }
     }
 }
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ParamList {
+    type Error = AstError<'a>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        Ok(ParamList(collect_recovered(pair.into_inner())?))
+    }
+}

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

@@ -1,22 +1,22 @@
 use crate::{
     Rule,
     ast::*,
-    ast_ensure, ast_expr,
-    error::{AstError, AstResult, GetLength, IntoErr, collect_recovered, collect_recovered_map},
+    ast_ensure,
+    error::{AstError, collect_recovered, collect_recovered_map},
     parser::consume_rule,
 };
 use pest::pratt_parser::PrattParser;
 use std::sync::OnceLock;
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::expr => {
+            Rule::expr | Rule::expr_no_struct => {
                 static PRATT_PARSER: OnceLock<PrattParser<Rule>> = OnceLock::new();
                 let pratt = PRATT_PARSER.get_or_init(|| {
                     use pest::pratt_parser::{Assoc::*, Op};
@@ -27,16 +27,16 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
                 pratt
                     .map_primary(|primary_pair| Expression::try_from(primary_pair))
                     .map_infix(|expr, op, rhs| {
-                        ast_expr!(Expression::Binary {
-                            lhs: expr.map(Box::new).get_map(Box::new),
-                            op: Ok(op.as_str().to_string()) as AstResult<'_, String>,
-                            rhs: rhs.map(Box::new).get_map(Box::new),
+                        Ok(Expression::Binary {
+                            lhs: expr.map(Box::new)?,
+                            op: op.as_str().to_string(),
+                            rhs: rhs.map(Box::new)?,
                         })
                     })
                     .parse(inner)
             }
 
-            Rule::term => {
+            Rule::term | Rule::term_no_struct => {
                 let mut prefix_pairs = Vec::new();
                 let mut primary_pair = None;
                 let mut postfix_pairs = Vec::new();
@@ -50,47 +50,51 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
                     }
                 }
 
-                let prefixes = collect_recovered::<Prefix, Prefix>(prefix_pairs.into_iter());
+                let prefixes = collect_recovered::<Prefix>(prefix_pairs.into_iter())?;
                 let exp = Expression::try_from(
                     primary_pair.expect("Term must contain a primary expression"),
-                );
-                let postfixes = collect_recovered::<Postfix, Postfix>(postfix_pairs.into_iter());
+                )?;
+                let postfixes = collect_recovered::<Postfix>(postfix_pairs.into_iter())?;
 
                 if postfixes.len() > 0 || prefixes.len() > 0 {
-                    ast_expr!(Expression::Fix {
-                        initial: exp.map(Box::new),
+                    Ok(Expression::Fix {
+                        initial: Box::new(exp),
                         prefixes: prefixes,
                         postfixes: postfixes,
                     })
                 } else {
-                    ast_expr!(use exp?, prefixes, postfixes)
+                    Ok(exp)
                 }
             }
 
-            Rule::tuple => {
-                ast_expr!(Expression::Literal(
-                    collect_recovered(pair.into_inner())
-                        .map(Literal::Tuple)
-                        .get_map(Literal::Tuple)
-                ))
-            }
+            Rule::tuple => Ok(Expression::Literal(Literal::Tuple(collect_recovered(
+                pair.into_inner(),
+            )?))),
+
+            Rule::closure => Ok(Expression::Closure {
+                return_type: consume_rule(&mut inner, Rule::type_expr)
+                    .map(TypeExpr::try_from)
+                    .transpose()?,
+                params: collect_recovered(inner.next().unwrap().into_inner())?,
+                body: Box::new(Expression::try_from(inner.next().unwrap())?),
+            }),
+
+            Rule::array => Ok(Expression::Array(collect_recovered(inner)?)),
+
+            Rule::array_repeat => Ok(Expression::ArrayRepeat(
+                Box::new(Expression::try_from(inner.next().unwrap())?),
+                Box::new(Expression::try_from(inner.next().unwrap())?),
+            )),
 
             Rule::primary => pair.into_inner().next().unwrap().try_into(),
-            Rule::static_path => ast_expr!(Expression::Path(pair.try_into())),
-            Rule::literal => ast_expr!(Expression::Literal(pair.try_into())),
-            Rule::expr_path => ast_expr!(Expression::Path(pair.try_into())),
-            Rule::statement_wrapper => {
-                let i = inner.next().unwrap();
-                match i.as_rule() {
-                    Rule::expr => i.try_into(),
-                    _ => ast_expr!(Expression::Statement(
-                        i.try_into().get_map(Box::new).map(Box::new)
-                    )),
-                }
-            }
-            Rule::statement | Rule::basic_stmt | Rule::control_flow => ast_expr!(
-                Expression::Statement(pair.try_into().get_map(Box::new).map(Box::new))
-            ),
+            Rule::static_path => Ok(Expression::Path(pair.try_into()?)),
+            Rule::literal => Ok(Expression::Literal(pair.try_into()?)),
+            Rule::expr_path => Ok(Expression::Path(pair.try_into()?)),
+            Rule::statement
+            | Rule::basic_stmt
+            | Rule::control_flow
+            | Rule::block
+            | Rule::unsafe_block => Ok(Expression::Statement(Box::new(pair.try_into()?))),
 
             _ => AstError::bug_unimplemented(pair),
         }
@@ -98,7 +102,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Prefix {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         Ok(match pair.as_rule() {
@@ -106,24 +110,8 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Prefix {
             Rule::deref_px => Self::Deref,
             Rule::mut_ref_px => Self::RefMut,
             Rule::ref_px => Self::Ref,
-            Rule::new_px => Self::New(
-                pair.into_inner()
-                    .next()
-                    .map(|v| v.try_into().get())
-                    .transpose()?,
-            ),
             Rule::not_px => Self::Not,
             Rule::neg_px => Self::Neg,
-            Rule::closure => {
-                let mut inner = pair.into_inner();
-
-                return ast_expr!(Self::Closure(
-                    consume_rule(&mut inner, Rule::type_expr)
-                        .map(TypeExpr::try_from)
-                        .transpose(),
-                    collect_recovered(inner.next().unwrap().into_inner())
-                ));
-            }
 
             _ => return AstError::bug_unimplemented(pair),
         })
@@ -131,7 +119,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Prefix {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Postfix {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
@@ -140,32 +128,42 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Postfix {
         match rule {
             Rule::postfix => Postfix::try_from(inner.next().unwrap()),
 
-            Rule::field_px => {
-                ast_expr!(Postfix::FieldAccess(
-                    inner.next().unwrap().try_into(),
-                    inner.next().map(Generics::try_from).transpose()
-                ))
-            }
+            Rule::field_px => Ok(Postfix::FieldAccess(
+                inner.next().unwrap().try_into()?,
+                inner.next().map(Generics::try_from).transpose()?,
+            )),
 
-            Rule::call_px => ast_expr!(Postfix::Call(collect_recovered(inner))),
+            Rule::tuple_field_px => Ok(Postfix::TupleFieldAccess(
+                inner.next().unwrap().as_str().parse().unwrap_or(255_u8),
+                inner.next().map(Generics::try_from).transpose()?,
+            )),
 
-            Rule::struct_px => ast_expr!(Postfix::StructCall(collect_recovered_map(inner, |p| {
+            Rule::call_px => Ok(Postfix::Call(collect_recovered(inner)?)),
+
+            Rule::struct_px => Ok(Postfix::StructCall(collect_recovered_map(inner, |p| {
                 let mut pi = p.into_inner();
                 Ok((
                     Identifier::try_from(pi.next().unwrap())?,
-                    Expression::try_from(pi.next().unwrap()).get()?,
+                    pi.next().map(Expression::try_from).transpose()?,
                 ))
-            }))),
+            })?)),
 
-            Rule::index_px => {
-                ast_expr!(Postfix::Index(Expression::try_from(inner.next().unwrap())))
-            }
+            Rule::index_px => Ok(Postfix::Index(Expression::try_from(inner.next().unwrap())?)),
 
-            Rule::macro_call_px => Ok(Postfix::MacroCall(inner.as_str().to_string())),
+            Rule::macro_call_paren => Ok(Postfix::MacroCall {
+                inner: inner.as_str().to_string(),
+                delimiter: MacroDelimiter::Paren,
+            }),
+            Rule::macro_call_bracket => Ok(Postfix::MacroCall {
+                inner: inner.as_str().to_string(),
+                delimiter: MacroDelimiter::Bracket,
+            }),
+            Rule::macro_call_brace => Ok(Postfix::MacroCall {
+                inner: inner.as_str().to_string(),
+                delimiter: MacroDelimiter::Brace,
+            }),
 
-            Rule::as_px => {
-                ast_expr!(Postfix::As(inner.next().unwrap().try_into()))
-            }
+            Rule::as_px => Ok(Postfix::As(inner.next().unwrap().try_into()?)),
 
             Rule::try_px => Ok(Postfix::Try),
 
@@ -178,25 +176,25 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Postfix {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ExprPath {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         ast_ensure!(pair, Rule::expr_path => {
-            ast_expr!(ExprPath(collect_recovered(pair.into_inner())))
+            Ok(ExprPath(collect_recovered(pair.into_inner())?))
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ExprPathSegment {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::expr_path_segment => {
-            ast_expr!(ExprPathSegment {
-                ident: Identifier::try_from(inner.next().unwrap()),
-                generics: inner.next().map(Generics::try_from).transpose(),
+            Ok(ExprPathSegment {
+                ident: Identifier::try_from(inner.next().unwrap())?,
+                generics: inner.next().map(Generics::try_from).transpose()?,
             })
         })
     }

crates/parser/src/parser/common/mod.rs

@@ -6,13 +6,13 @@ pub mod types;
 use crate::{
     Rule,
     ast::*,
-    ast_ensure, ast_expr,
-    error::{AstError, AstResult, IntoErr, collect_recovered, collect_recovered_map},
+    ast_ensure,
+    error::{AstError, collect_recovered, collect_recovered_map},
     parser::{consume_rule, listen_rule},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Identifier {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         ast_ensure!(pair, Rule::identifier => {
@@ -22,18 +22,18 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Identifier {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Path {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
-            Rule::static_path => Ok(Path(collect_recovered(pair.into_inner()).get()?)),
+            Rule::static_path => Ok(Path(collect_recovered(pair.into_inner())?)),
             _ => AstError::bug_unimplemented(pair),
         }
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Literal {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
@@ -46,54 +46,69 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Literal {
             Rule::float => Literal::Float(pair.as_str().parse::<f64>().unwrap()),
             Rule::boolean => Literal::Bool(pair.as_str().parse::<bool>().unwrap()),
             Rule::string_lit => Literal::String(inner.as_str().to_string()),
-            Rule::tuple => Literal::Tuple(collect_recovered(inner).get()?),
+            Rule::tuple => Literal::Tuple(collect_recovered(inner)?),
             _ => return AstError::bug_unimplemented(pair),
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Pattern {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::tuple_pattern => ast_expr!(Pattern::Tuple(collect_recovered_map(inner, |v| {
+            Rule::tuple_pattern => Ok(Pattern::Tuple(collect_recovered_map(inner, |v| {
                 Self::try_from(v).map(Box::new)
-            }))),
+            })?)),
 
-            Rule::named_tuple_pattern => ast_expr!(Pattern::NamedTuple(
-                Path::try_from(inner.next().unwrap()),
-                collect_recovered_map(inner, |v| Self::try_from(v).map(Box::new)),
+            Rule::named_tuple_pattern => Ok(Pattern::NamedTuple(
+                Path::try_from(inner.next().unwrap())?,
+                collect_recovered_map(inner, |v| Self::try_from(v).map(Box::new))?,
             )),
 
-            Rule::struct_pattern => ast_expr!(Pattern::Struct(
-                Path::try_from(inner.next().unwrap()),
-                collect_recovered_map(inner, |v| Self::try_from(v).map(Box::new)),
+            Rule::struct_pattern => Ok(Pattern::Struct(
+                Path::try_from(inner.next().unwrap())?,
+                collect_recovered_map(inner, |v| {
+                    if v.as_rule() == Rule::etc_pattern {
+                        return Ok(None);
+                    }
+
+                    let mut inner = v.into_inner();
+                    Ok(Some((
+                        Identifier::try_from(inner.next().unwrap())?,
+                        inner
+                            .next()
+                            .map(|v| Self::try_from(v).map(Box::new))
+                            .transpose()?,
+                    )))
+                })?,
             )),
 
-            Rule::literal => ast_expr!(Pattern::Literal(pair.try_into())),
+            Rule::literal => Ok(Pattern::Literal(pair.try_into()?)),
 
-            Rule::path_pattern => ast_expr!(Pattern::Path(
-                Ok(listen_rule(&mut inner, Rule::mutable)) as AstResult<'_, bool>,
-                inner.next().unwrap().try_into()
+            Rule::path_pattern => Ok(Pattern::Path(
+                listen_rule(&mut inner, Rule::mutable),
+                inner.next().unwrap().try_into()?,
             )),
 
+            Rule::etc_pattern => Ok(Pattern::Etc),
+
             _ => AstError::bug_unimplemented(pair),
         }
     }
 }
 
 impl<'a> TryFrom<&mut pest::iterators::Pairs<'a, Rule>> for Visibility {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pairs: &mut pest::iterators::Pairs<'a, Rule>) -> Result<Self, Self::Error> {
         Ok(consume_rule(pairs, Rule::visibility)
-            .map(|pair| -> Result<Visibility, AstError<'a, Self>> {
+            .map(|pair| -> Result<Visibility, AstError<'a>> {
                 if let Some(path) = pair.into_inner().next() {
-                    ast_expr!(Visibility::PublicTarget(Path::try_from(path)))
+                    Ok(Visibility::PublicTarget(Path::try_from(path)?))
                 } else {
                     Ok(Visibility::Public)
                 }

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

@@ -1,57 +1,42 @@
 use crate::{
     Rule,
     ast::*,
-    ast_ensure, ast_expr,
-    error::{AstError, IntoErr, collect_recovered},
+    ast_ensure,
+    error::{AstError, collect_recovered},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Block {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::block => {
-            ast_expr!(Block(collect_recovered(inner.next().unwrap().into_inner()), inner.next().map(Spanned::try_from).transpose()))
+            Ok(Block {
+                statements: collect_recovered(inner.next().unwrap().into_inner())?,
+                soft_return: inner.next().map(Spanned::try_from).transpose()?,
             })
-    }
-}
-
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for StatementBody {
-    type Error = AstError<'a, Self>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let mut inner = pair.clone().into_inner();
-
-        ast_ensure!(pair, Rule::statement_body => {
-            let i = inner.next().unwrap();
-
-            match i.as_rule() {
-                Rule::expr => ast_expr!(StatementBody::Expression(i.try_into())),
-                Rule::statement_wrapper => ast_expr!(StatementBody::Statement(i.try_into())),
-                _ => AstError::bug_unimplemented(i),
-            }
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for StatementBranch {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::statement_branch => {
-            ast_expr!(StatementBranch {
-                condition: inner.next().unwrap().try_into(),
-                body: inner.next().unwrap().try_into().map(Box::new),
+            Ok(StatementBranch {
+                condition: inner.next().unwrap().try_into()?,
+                body: Box::new(inner.next().unwrap().try_into()?),
             })
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
@@ -62,48 +47,46 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
                 Statement::try_from(inner.next().unwrap())
             }
 
-            Rule::block => ast_expr!(Statement::Block(pair.try_into())),
+            Rule::unsafe_block => Ok(Statement::UnsafeBlock(inner.next().unwrap().try_into()?)),
 
-            Rule::var_decl_statement => ast_expr!(Statement::VarDecl(pair.try_into())),
+            Rule::block => Ok(Statement::Block(pair.try_into()?)),
 
-            Rule::return_stmt => {
-                ast_expr!(Statement::Return(
-                    inner.next().map(Expression::try_from).transpose()
-                ))
-            }
+            Rule::var_decl_statement => Ok(Statement::VarDecl(pair.try_into()?)),
+
+            Rule::return_stmt => Ok(Statement::Return(
+                inner.next().map(Expression::try_from).transpose()?,
+            )),
 
             Rule::break_stmt => Ok(Statement::Break),
 
             Rule::continue_stmt => Ok(Statement::Continue),
 
-            Rule::if_stmt => {
-                ast_expr!(Statement::If {
-                    initial: inner.next().unwrap().try_into(),
-                    else_if: collect_recovered(inner.next().unwrap().into_inner()),
-                    else_branch: inner.next().map(StatementBody::try_from).transpose(),
-                })
-            }
-
-            Rule::while_stmt => ast_expr!(Statement::While(inner.next().unwrap().try_into())),
-
-            Rule::loop_stmt => ast_expr!(Statement::Loop(inner.next().unwrap().try_into())),
-
-            Rule::c_for_stmt => ast_expr!(Statement::CStyleFor {
-                init: inner.next().unwrap().try_into(),
-                condition: inner.next().unwrap().try_into(),
-                update: inner.next().unwrap().try_into(),
-                body: inner.next().unwrap().try_into(),
+            Rule::if_stmt => Ok(Statement::If {
+                initial: inner.next().unwrap().try_into()?,
+                else_if: collect_recovered(inner.next().unwrap().into_inner())?,
+                else_branch: inner.next().map(Block::try_from).transpose()?,
             }),
 
-            Rule::for_stmt => ast_expr!(Statement::For {
-                pattern: inner.next().unwrap().try_into(),
-                iterator: inner.next().unwrap().try_into(),
-                body: inner.next().unwrap().try_into(),
+            Rule::while_stmt => Ok(Statement::While(inner.next().unwrap().try_into()?)),
+
+            Rule::loop_stmt => Ok(Statement::Loop(inner.next().unwrap().try_into()?)),
+
+            Rule::c_for_stmt => Ok(Statement::CStyleFor {
+                init: inner.next().unwrap().try_into()?,
+                condition: inner.next().unwrap().try_into()?,
+                update: inner.next().unwrap().try_into()?,
+                body: inner.next().unwrap().try_into()?,
             }),
 
-            Rule::match_stmt => ast_expr!(Statement::Match(
-                inner.next().unwrap().try_into(),
-                collect_recovered(inner),
+            Rule::for_stmt => Ok(Statement::For {
+                pattern: inner.next().unwrap().try_into()?,
+                iterator: inner.next().unwrap().try_into()?,
+                body: inner.next().unwrap().try_into()?,
+            }),
+
+            Rule::match_stmt => Ok(Statement::Match(
+                inner.next().unwrap().try_into()?,
+                collect_recovered(inner)?,
             )),
 
             _ => AstError::bug_unimplemented(pair),
@@ -112,14 +95,14 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for MatchItem {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut match_inner = pair.into_inner();
 
         Ok(MatchItem(
-            collect_recovered(match_inner.next().unwrap().into_inner()).get()?,
-            Expression::try_from(match_inner.next().unwrap()).get()?,
+            collect_recovered(match_inner.next().unwrap().into_inner())?,
+            Expression::try_from(match_inner.next().unwrap())?,
         ))
     }
 }

crates/parser/src/parser/common/types.rs

@@ -1,88 +1,90 @@
 use crate::{
     Rule,
     ast::*,
-    ast_ensure, ast_expr,
-    error::{AstError, GetLength, IntoErr, collect_recovered},
+    ast_ensure,
+    error::{AstError, collect_recovered},
     parser::{consume_rule, listen_rule},
 };
 
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypePostfix {
-    type Error = AstError<'a, Self>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let rule = pair.as_rule();
-        let mut inner = pair.clone().into_inner();
-
-        match rule {
-            Rule::ref_type => {
-                let mutable = listen_rule(&mut inner, Rule::mutable);
-                let lifetime = consume_rule(&mut inner, Rule::lifetime)
-                    .map(|pair| Identifier::try_from(pair.into_inner().next().unwrap()))
-                    .transpose()
-                    .get()?;
-
-                Ok(if mutable {
-                    if let Some(lifetime) = lifetime {
-                        TypePostfix::RefMutLifetime(lifetime)
-                    } else {
-                        TypePostfix::RefMut
-                    }
-                } else {
-                    if let Some(lifetime) = lifetime {
-                        TypePostfix::RefLifetime(lifetime)
-                    } else {
-                        TypePostfix::Ref
-                    }
-                })
-            }
-
-            Rule::dyn_type => Ok(TypePostfix::Dyn),
-
-            _ => AstError::bug_unimplemented(pair),
-        }
-    }
-}
-
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExprKind {
-    type Error = AstError<'a, Self>;
-
-    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let rule = pair.as_rule();
-        let mut inner = pair.clone().into_inner();
-
-        match rule {
-            Rule::tuple_type => ast_expr!(TypeExprKind::Tuple(collect_recovered(inner))),
-            Rule::path_type => {
-                let path = Path::try_from(inner.next().unwrap());
-                let params = collect_recovered(inner);
-
-                if params.len() == 0 {
-                    ast_expr!(TypeExprKind::Path(path))
-                } else {
-                    ast_expr!(TypeExprKind::PathParams(path, params))
-                }
-            }
-            _ => AstError::bug_unimplemented(pair),
-        }
-    }
-}
-
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExpr {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::type_expr => ast_expr!(TypeExpr(
-                inner.next().unwrap().try_into(),
-                collect_recovered(inner),
+            Rule::generic => Self::try_from(inner.next().unwrap()),
+            Rule::type_expr => {
+                let mut inner = inner;
+
+                let mut ty = TypeExpr::try_from(inner.next().unwrap())?;
+
+                for ref_pair in inner {
+                    let mut ref_inner = ref_pair.clone().into_inner();
+
+                    match ref_pair.as_rule() {
+                        Rule::ref_type => {
+                            ty = TypeExpr::Ref {
+                                mutable: listen_rule(&mut ref_inner, Rule::mutable),
+                                lifetime: consume_rule(&mut ref_inner, Rule::lifetime)
+                                    .map(|v| v.into_inner().next().map(Identifier::try_from))
+                                    .unwrap_or_default()
+                                    .transpose()?,
+                                ty: Box::new(ty),
+                            };
+                        }
+
+                        Rule::unsafe_ref_type => {
+                            ty = TypeExpr::UnsafePtr {
+                                mutable: listen_rule(&mut ref_inner, Rule::mutable),
+                                ty: Box::new(ty),
+                            };
+                        }
+
+                        Rule::fn_type => {
+                            ty = TypeExpr::Fn {
+                                return_type: Box::new(ty),
+                                kind: ref_inner.next().unwrap().try_into()?,
+                                params: collect_recovered(ref_inner)?,
+                            };
+                        }
+
+                        _ => 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)?)),
+
+            Rule::path_type => Ok(TypeExpr::Path(
+                Path::try_from(inner.next().unwrap())?,
+                inner.next().map(Generics::try_from).transpose()?,
             )),
-            Rule::type_expr_param => Self::try_from(inner.next().unwrap()),
-            Rule::lifetime => ast_expr!(TypeExprKind::Lifetime(inner.next().unwrap().try_into()))
-                .get_map(TypeExpr::no_px)
-                .map(TypeExpr::no_px),
+
+            Rule::dyn_type => Ok(TypeExpr::Dyn(
+                TypeExpr::try_from(inner.next().unwrap()).map(Box::new)?,
+            )),
+
+            _ => AstError::bug_unimplemented(pair),
+        }
+    }
+}
+
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FnKind {
+    type Error = AstError<'a>;
+
+    fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
+        match pair.as_rule() {
+            Rule::fn_kind_fn => Ok(FnKind::Fn),
+            Rule::fn_kind_unsafe => Ok(FnKind::UnsafeFn),
+            Rule::fn_kind_closure => Ok(FnKind::FnClosure),
+            Rule::fn_kind_once => Ok(FnKind::FnOnce),
+            Rule::fn_kind_mut => Ok(FnKind::FnMut),
 
             _ => AstError::bug_unimplemented(pair),
         }
@@ -90,32 +92,32 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TypeExpr {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for GenericsDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::generics_decl => {
-            ast_expr!(GenericsDecl(collect_recovered(inner)))
+            Ok(GenericsDecl(collect_recovered(inner)?))
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for GenericDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::generic_decl => {
             if let Some(pair) = consume_rule(&mut inner, Rule::lifetime) {
-                ast_expr!(GenericDecl::Lifetime(
-                    pair.into_inner().next().unwrap().try_into(),
+                Ok(GenericDecl::Lifetime(
+                    pair.into_inner().next().unwrap().try_into()?,
                 ))
             } else {
-                ast_expr!(GenericDecl::Type(
-                    inner.next().unwrap().try_into(),
-                    collect_recovered(inner),
+                Ok(GenericDecl::Type(
+                    inner.next().unwrap().try_into()?,
+                    collect_recovered(inner)?,
                 ))
             }
         })
@@ -123,31 +125,31 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for GenericDecl {
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generics {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::generics => {
-            ast_expr!(Generics(collect_recovered(inner)))
+            Ok(Generics(collect_recovered(inner)?))
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Generic {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.clone().into_inner();
 
         ast_ensure!(pair, Rule::generic => {
             if let Some(pair) = consume_rule(&mut inner, Rule::lifetime) {
-                ast_expr!(Generic::Lifetime(
-                    pair.into_inner().next().unwrap().try_into(),
+                Ok(Generic::Lifetime(
+                    pair.into_inner().next().unwrap().try_into()?,
                 ))
             } else {
-                ast_expr!(Generic::Type(
-                    inner.next().unwrap().try_into()
+                Ok(Generic::Type(
+                    inner.next().unwrap().try_into()?
                 ))
             }
         })

crates/parser/src/parser/items/attribute.rs

@@ -1,11 +1,11 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, IntoErr, collect_recovered},
+    error::{AstError, collect_recovered},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Attribute {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         match pair.as_rule() {
@@ -18,7 +18,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Attribute {
                 let mut inner = pair.into_inner();
 
                 // first item is always the path
-                let path = inner.next().unwrap().try_into().get()?;
+                let path = inner.next().unwrap().try_into()?;
 
                 // check what comes next
                 match inner.next() {
@@ -32,7 +32,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Attribute {
                             // #[path = literal]
                             Ok(Attribute::NameValue {
                                 path,
-                                value: next.try_into().get()?,
+                                value: next.try_into()?,
                             })
                         }
 
@@ -40,7 +40,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Attribute {
                             // #[path(...)]
                             Ok(Attribute::List {
                                 path,
-                                items: collect_recovered(next.into_inner()).get()?,
+                                items: collect_recovered(next.into_inner())?,
                             })
                         }
 

crates/parser/src/parser/items/class.rs

@@ -1,48 +1,39 @@
-use crate::{
-    Rule,
-    ast::*,
-    error::{AstError, IntoErr},
-    parser::consume_rule,
-};
+use crate::{Rule, ast::*, error::AstError, parser::consume_rule};
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ClassConstructor {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let mut inner = pair.into_inner();
 
         Ok(Self {
-            visibility: Visibility::try_from(&mut inner).get()?,
+            visibility: Visibility::try_from(&mut inner)?,
 
             generics: consume_rule(&mut inner, Rule::generics_decl)
                 .map(GenericsDecl::try_from)
-                .transpose()
-                .get()?
+                .transpose()?
                 .unwrap_or_default(),
 
             params: consume_rule(&mut inner, Rule::param_list)
                 .map(ParamList::try_from)
-                .transpose()
-                .get()?
+                .transpose()?
                 .unwrap_or_default(),
 
-            body: inner.next().unwrap().try_into().get()?,
+            body: inner.next().unwrap().try_into()?,
         })
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ClassItem {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
 
         match rule {
-            Rule::impl_decl | Rule::impl_for_decl => {
-                Ok(ClassItem::ImplDecl(pair.try_into().get()?))
-            }
+            Rule::impl_decl | Rule::impl_for_decl => Ok(ClassItem::ImplDecl(pair.try_into()?)),
 
-            Rule::method => Ok(ClassItem::Method(pair.try_into().get()?)),
+            Rule::function_decl => Ok(ClassItem::Method(pair.try_into()?)),
 
             _ => AstError::bug_unimplemented(pair),
         }

crates/parser/src/parser/items/enums.rs

@@ -1,31 +1,30 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, IntoErr, collect_recovered},
+    error::{AstError, collect_recovered},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for EnumItem {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::enum_named => Ok(EnumItem::Named(inner.next().unwrap().try_into().get()?)),
+            Rule::enum_named => Ok(EnumItem::Named(inner.next().unwrap().try_into()?)),
 
             Rule::enum_tuple => Ok(EnumItem::Tuple(
-                inner.next().unwrap().try_into().get()?,
-                collect_recovered(inner.next().unwrap().into_inner()).get()?,
+                inner.next().unwrap().try_into()?,
+                collect_recovered(inner.next().unwrap().into_inner())?,
             )),
 
             Rule::enum_struct => Ok(EnumItem::Struct(
-                inner.next().unwrap().try_into().get()?,
+                inner.next().unwrap().try_into()?,
                 inner
                     .next()
-                    .map(|pair| collect_recovered::<FieldDecl, FieldDecl>(pair.into_inner()))
-                    .transpose()
-                    .get()?
+                    .map(|pair| collect_recovered::<FieldDecl>(pair.into_inner()))
+                    .transpose()?
                     .unwrap_or_default(),
             )),
 

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

@@ -1,69 +1,55 @@
 use crate::{
     Rule,
     ast::*,
-    ast_ensure, ast_expr,
-    error::{AstError, AstResult, IntoErr, collect_recovered},
-    parser::{consume_rule, listen_rule},
+    ast_ensure,
+    error::{AstError, AstResult},
+    parser::{consume_rule, consume_rule_map, listen_rule},
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        ast_ensure!(pair, Rule::function_decl, Rule::method, Rule::method_no_body => {
+        ast_ensure!(pair, Rule::function_decl => {
         let mut inner = pair.into_inner();
-            let visibility = Visibility::try_from(&mut inner);
-            let return_type = TypeExpr::try_from(inner.next().unwrap());
-            let name = Identifier::try_from(inner.next().unwrap());
+            let visibility = Visibility::try_from(&mut inner)?;
+
+            let return_type = consume_rule(&mut inner, Rule::type_expr)
+                .map(TypeExpr::try_from)
+                .transpose()?;
+
+            let name = Identifier::try_from(inner.next().unwrap())?;
 
             let generics = consume_rule(&mut inner, Rule::generics_decl)
                 .map(GenericsDecl::try_from)
                 .transpose()
-                .map(|v| v.unwrap_or_default());
+                .map(|v| v.unwrap_or_default())?;
 
-            let self_param = consume_rule(&mut inner, Rule::self_param).map(|param| {
+            let self_param = consume_rule_map(&mut inner, Rule::self_param, |param| {
                 let mut param_inner = param.into_inner();
+
+                let is_ref = listen_rule(&mut param_inner, Rule::ref_px);
+                let lifetime = consume_rule(&mut param_inner, Rule::lifetime);
                 let mutable = listen_rule(&mut param_inner, Rule::mutable);
-                let is_ref = listen_rule(&mut param_inner, Rule::deref_px);
-                let name = Pattern::Path(mutable && !is_ref, Path(vec![Identifier(String::from("self"))]));
 
-                VarDecl {
-                    name: name.clone(),
-                    type_: Some(TypeExpr(
-                        TypeExprKind::Path(Path(vec![Identifier("Self".to_string())])),
-                        if is_ref {
-                            vec![if mutable {
-                                TypePostfix::RefMut
-                            } else {
-                                TypePostfix::Ref
-                            }]
-                        } else {
-                            Vec::new()
-                        },
-                    )),
-                }
-            });
+                Ok((is_ref, lifetime.map(|v| -> AstResult<Identifier> {
+                    Identifier::try_from(v.into_inner().next().unwrap())
+                }).transpose()?, mutable))
+            })?;
 
-            let params = consume_rule(&mut inner, Rule::param_list)
-                .map({
-                    let self_param = self_param.clone();
-                    |params_pair| -> AstResult<'a, ParamList> {
-                        let mut params = ParamList::try_from(params_pair)?;
-                        if let Some(x) = self_param {
-                            params.0.insert(0, x);
-                        }
-                        Ok(params)
-                    }
-                })
-                .unwrap_or_else(|| Ok(ParamList(self_param.into_iter().collect())));
+            let params = consume_rule(&mut inner, Rule::param_list).map(ParamList::try_from).transpose()?.unwrap_or_default();
 
-            let body = inner.next().map(Block::try_from).transpose();
+            let is_override = consume_rule(&mut inner, Rule::override_kw).map(Override::try_from).transpose()?;
 
-            ast_expr!(Self {
+            let body = inner.next().map(Block::try_from).transpose()?;
+
+            Ok(Self {
                 visibility: visibility,
+                is_override: is_override,
                 return_type: return_type,
                 name: name,
                 generics: generics,
+                self_param: self_param,
                 params: params,
                 body: body,
             })
@@ -71,10 +57,12 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for FunctionDecl {
     }
 }
 
-impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ParamList {
-    type Error = AstError<'a, Self>;
+impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Override {
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        Ok(ParamList(collect_recovered(pair.into_inner()).get()?))
+        ast_ensure!(pair, Rule::override_kw => {
+            Ok(Override(pair.into_inner().next().map(ExprPath::try_from).transpose()?))
+        })
     }
 }

crates/parser/src/parser/items/impl_decl.rs

@@ -1,12 +1,12 @@
 use crate::{
     Rule,
     ast::*,
-    error::{AstError, IntoErr, collect_recovered},
+    error::{AstError, collect_recovered},
     parser::consume_rule,
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ImplDecl {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
@@ -16,23 +16,21 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for ImplDecl {
             Rule::impl_for_decl => Ok(ImplDecl {
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
-                    .transpose()
-                    .get()?
+                    .transpose()?
                     .unwrap_or_default(),
-                trait_: Some(inner.next().unwrap().try_into().get()?),
-                target: inner.next().unwrap().try_into().get()?,
-                methods: collect_recovered(inner).get()?,
+                trait_: Some(inner.next().unwrap().try_into()?),
+                target: inner.next().unwrap().try_into()?,
+                methods: collect_recovered(inner)?,
             }),
 
             Rule::impl_decl => Ok(ImplDecl {
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
-                    .transpose()
-                    .get()?
+                    .transpose()?
                     .unwrap_or_default(),
                 trait_: None,
-                target: inner.next().unwrap().try_into().get()?,
-                methods: collect_recovered(inner).get()?,
+                target: inner.next().unwrap().try_into()?,
+                methods: collect_recovered(inner)?,
             }),
 
             _ => AstError::bug_unimplemented(pair),

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

@@ -7,117 +7,119 @@ pub mod impl_decl;
 use crate::{
     Rule,
     ast::*,
-    ast_expr,
-    error::{AstError, IntoErr, collect_recovered},
+    error::{AstError, collect_recovered},
     parser::consume_rule,
 };
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TopLevel {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
-        let mut inner = pair.into_inner();
+        let mut inner = pair.clone().into_inner();
 
-        let attributes = collect_recovered(inner.next().unwrap().into_inner());
+        let attributes = collect_recovered(inner.next().unwrap().into_inner())?;
 
-        ast_expr!(TopLevel(
-            inner.next().map(Spanned::try_from).unwrap(),
+        Ok(TopLevel(
+            inner
+                .next()
+                .map(Spanned::try_from)
+                .unwrap_or_else(move || Ok(Spanned::new_pair(pair, TopLevelKind::ModAttribute)))?,
             attributes,
         ))
     }
 }
 
 impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for TopLevelKind {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::import => ast_expr!(TopLevelKind::Import(
-                Visibility::try_from(&mut inner),
-                Path::try_from(inner.next().unwrap()),
+            Rule::import => Ok(TopLevelKind::Import(
+                Visibility::try_from(&mut inner)?,
+                Path::try_from(inner.next().unwrap())?,
             )),
 
-            Rule::function_decl => ast_expr!(TopLevelKind::FunctionDecl(pair.try_into())),
+            Rule::function_decl => Ok(TopLevelKind::FunctionDecl(pair.try_into()?)),
 
-            Rule::struct_decl => ast_expr!(TopLevelKind::StructDecl {
-                visibility: Visibility::try_from(&mut inner),
+            Rule::struct_decl => Ok(TopLevelKind::StructDecl {
+                visibility: Visibility::try_from(&mut inner)?,
 
-                name: inner.next().unwrap().try_into(),
+                name: inner.next().unwrap().try_into()?,
 
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
 
                 fields: inner
                     .next()
                     .map(|pair| collect_recovered(pair.into_inner()))
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
             }),
 
-            Rule::class_decl => ast_expr!(TopLevelKind::ClassDecl {
-                visibility: Visibility::try_from(&mut inner),
+            Rule::class_decl => Ok(TopLevelKind::ClassDecl {
+                visibility: Visibility::try_from(&mut inner)?,
 
-                name: inner.next().unwrap().try_into(),
+                name: inner.next().unwrap().try_into()?,
 
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
 
-                inherits: consume_rule(&mut inner, Rule::type_expr)
-                    .map(TypeExpr::try_from)
-                    .transpose(),
+                inherits: consume_rule(&mut inner, Rule::expr_path)
+                    .map(ExprPath::try_from)
+                    .transpose()?,
 
-                fields: collect_recovered(inner.next().unwrap().into_inner()),
+                fields: collect_recovered(inner.next().unwrap().into_inner())?,
 
-                constructor: inner.next().unwrap().try_into(),
+                constructor: consume_rule(&mut inner, Rule::class_constructor)
+                    .map(Spanned::try_from)
+                    .transpose()?,
 
-                items: collect_recovered(inner),
+                items: collect_recovered(inner)?,
             }),
 
-            Rule::enum_decl => ast_expr!(TopLevelKind::EnumDecl {
-                visibility: Visibility::try_from(&mut inner),
+            Rule::enum_decl => Ok(TopLevelKind::EnumDecl {
+                visibility: Visibility::try_from(&mut inner)?,
 
-                name: inner.next().unwrap().try_into(),
+                name: inner.next().unwrap().try_into()?,
 
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
 
-                fields: collect_recovered(inner),
+                fields: collect_recovered(inner)?,
             }),
 
-            Rule::mod_package => ast_expr!(TopLevelKind::Mod(
-                Visibility::try_from(&mut inner),
-                inner.next().unwrap().try_into(),
+            Rule::declare_module => Ok(TopLevelKind::DeclareModule(
+                Visibility::try_from(&mut inner)?,
+                inner.next().unwrap().try_into()?,
             )),
 
-            Rule::impl_for_decl | Rule::impl_decl => {
-                ast_expr!(TopLevelKind::ImplDecl(pair.try_into()))
-            }
+            Rule::impl_for_decl | Rule::impl_decl => Ok(TopLevelKind::ImplDecl(pair.try_into()?)),
 
-            Rule::trait_decl => ast_expr!(TopLevelKind::TraitDecl {
-                visibility: Visibility::try_from(&mut inner),
+            Rule::trait_decl => Ok(TopLevelKind::TraitDecl {
+                visibility: Visibility::try_from(&mut inner)?,
 
-                name: inner.next().unwrap().try_into(),
+                name: inner.next().unwrap().try_into()?,
 
                 generics: consume_rule(&mut inner, Rule::generics_decl)
                     .map(GenericsDecl::try_from)
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
 
                 requirements: consume_rule(&mut inner, Rule::trait_requirements)
                     .map(|pair| collect_recovered(pair.into_inner()))
                     .transpose()
-                    .map(|v| v.unwrap_or_default()),
+                    .map(|v| v.unwrap_or_default())?,
 
-                items: collect_recovered(&mut inner),
+                items: collect_recovered(&mut inner)?,
             }),
 
             _ => AstError::bug_unimplemented(pair),

crates/parser/src/parser/mod.rs

@@ -1,7 +1,11 @@
 pub mod common;
 pub mod items;
 
-use crate::{Rule, ast::Spanned, error::AstError};
+use crate::{
+    Rule,
+    ast::Spanned,
+    error::{AstError, AstResult},
+};
 
 pub fn listen_rule(pairs: &mut pest::iterators::Pairs<'_, Rule>, rule: Rule) -> bool {
     let consumed = pairs
@@ -28,10 +32,36 @@ pub fn consume_rule<'a>(
     if consumed { pairs.next() } else { None }
 }
 
-impl<'a, T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a, T>>>
+pub fn consume_rule_map<'a, T>(
+    pairs: &mut pest::iterators::Pairs<'a, Rule>,
+    rule: Rule,
+    map: impl Fn(pest::iterators::Pair<'a, Rule>) -> AstResult<'a, T>,
+) -> AstResult<'a, Option<T>> {
+    let pair = consume_rule(pairs, rule);
+
+    if let Some(pair) = pair {
+        Some(map(pair)).transpose()
+    } else {
+        Ok(None)
+    }
+}
+
+impl<T> Spanned<T> {
+    fn new_pair(pair: pest::iterators::Pair<'_, Rule>, item: T) -> Self {
+        let span = pair.as_span().start_pos().line_col();
+
+        Self {
+            line: span.0,
+            column: span.1,
+            item,
+        }
+    }
+}
+
+impl<'a, T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a>>>
     TryFrom<pest::iterators::Pair<'a, Rule>> for Spanned<T>
 {
-    type Error = AstError<'a, Self>;
+    type Error = AstError<'a>;
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let span = pair.as_span().start_pos().line_col();
@@ -39,16 +69,7 @@ impl<'a, T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a, T>>>
         Ok(Self {
             line: span.0,
             column: span.1,
-            item: pair.try_into().map_err(|err: AstError<'_, T>| AstError {
-                span: err.span,
-                error_code: err.error_code,
-                error_message: err.error_message,
-                recovered: err.recovered.map(|v| Spanned {
-                    line: span.0,
-                    column: span.1,
-                    item: v,
-                }),
-            })?,
+            item: pair.try_into()?,
         })
     }
 }

crates/parser/src/rev_mapper.rs

@@ -0,0 +1,78 @@
+use std::{collections::HashSet, path::PathBuf};
+
+use serde::{Deserialize, Serialize};
+
+#[derive(
+    Debug, Default, 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,
+)]
+pub struct RustMap(pub usize, pub usize);
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Mapping {
+    pub mist_path: PathBuf,
+    pub map: HashSet<(RustMap, MistMap)>,
+}
+
+impl Mapping {
+    pub fn new(mist_path: PathBuf) -> Self {
+        Self {
+            mist_path,
+            map: HashSet::new(),
+        }
+    }
+
+    pub fn find(&self, target: &RustMap) -> Option<(RustMap, MistMap)> {
+        self.map
+            .iter()
+            .copied()
+            .filter(|(rust, _)| rust <= target)
+            .max_by_key(|(rust, _)| *rust)
+    }
+
+    pub fn find_by_mist(&self, target: &MistMap) -> Option<(RustMap, MistMap)> {
+        self.map
+            .iter()
+            .copied()
+            .filter(|(_, mist)| mist <= target)
+            .max_by_key(|(_, mist)| *mist)
+    }
+
+    pub fn shift_rust(&mut self, lines: isize, cols: isize) {
+        self.map = self
+            .map
+            .iter()
+            .map(|(rust, mist)| (rust.shifted(lines, cols), *mist))
+            .collect();
+    }
+
+    pub fn shift_mist(&mut self, lines: isize, cols: isize) {
+        self.map = self
+            .map
+            .iter()
+            .map(|(rust, mist)| (*rust, mist.shifted(lines, cols)))
+            .collect();
+    }
+}
+
+impl RustMap {
+    pub fn shifted(self, lines: isize, cols: isize) -> Self {
+        Self(
+            self.0.saturating_add_signed(lines),
+            self.1.saturating_add_signed(cols),
+        )
+    }
+}
+
+impl MistMap {
+    pub fn shifted(self, lines: isize, cols: isize) -> Self {
+        Self(
+            self.0.saturating_add_signed(lines),
+            self.1.saturating_add_signed(cols),
+        )
+    }
+}

crates/parser/src/rev_mapper/grammar.pest

@@ -1,9 +0,0 @@
-WHITESPACE = _{ " " | "\t" | "\r" | "\n" }
-
-integer = @{ ASCII_DIGIT+ }
-
-map = { "/*" ~ integer ~ ":" ~ integer ~ "*/" }
-
-non_map = { (!map ~ ANY)+ }
-
-mapping = { SOI ~ (map | non_map)* ~ EOI }

crates/parser/src/rev_mapper/mod.rs

@@ -1,51 +0,0 @@
-use std::collections::HashSet;
-
-use pest::Parser;
-use pest_derive::Parser;
-
-#[derive(Parser)]
-#[grammar = "./src/rev_mapper/grammar.pest"]
-pub struct MistMapperParser;
-
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct MistMap(pub usize, pub usize);
-
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct RustMap(pub usize, pub usize);
-
-pub fn get_mapping(input: &str) -> HashSet<(RustMap, MistMap)> {
-    let mut mapping = HashSet::new();
-
-    let pairs = MistMapperParser::parse(Rule::mapping, input)
-        .unwrap()
-        .next()
-        .unwrap()
-        .into_inner();
-
-    for pair in pairs {
-        if pair.as_rule() == Rule::map {
-            let rs = pair.as_span().start_pos().line_col();
-            let mut inner = pair.into_inner();
-
-            let (line, col) = (
-                inner.next().unwrap().as_str().parse().unwrap(),
-                inner.next().unwrap().as_str().parse().unwrap(),
-            );
-
-            mapping.insert((RustMap(rs.0, rs.1), MistMap(line, col)));
-        }
-    }
-
-    mapping
-}
-
-pub fn find_mapping(
-    mapping: &HashSet<(RustMap, MistMap)>,
-    target: &RustMap,
-) -> Option<(RustMap, MistMap)> {
-    mapping
-        .iter()
-        .copied()
-        .filter(|(rust, _)| rust <= target)
-        .max_by_key(|(rust, _)| *rust)
-}

crates/parser/src/semantics.rs

@@ -0,0 +1,361 @@
+use crate::ast::{
+    Block, ClassItem, Expression, FunctionDecl, Identifier, MatchItem, Postfix, Prefix, Spanned,
+    Statement, StatementBranch, TopLevel, TopLevelKind, VarDeclStmt,
+};
+
+pub trait GetMutability {
+    fn get_mutability(&self) -> Vec<Identifier>;
+}
+
+#[derive(Debug, Clone)]
+pub struct SemanticError {
+    pub line: usize,
+    pub column: usize,
+    pub error_message: String,
+}
+
+/// Class semantics - Ensuring fields are initialized
+
+pub fn find_function_call<'a>(
+    items: &'a Vec<ClassItem>,
+    name: &Identifier,
+) -> Option<&'a Spanned<FunctionDecl>> {
+    items.iter().find_map(|v| {
+        if let ClassItem::Method(m) = v {
+            if m.item.self_param.is_some() && &m.item.name == name {
+                Some(m)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    })
+}
+
+pub fn check_class_semantics<'a>(top_level: &TopLevel) -> Result<(), Vec<SemanticError>> {
+    if let TopLevelKind::ClassDecl {
+        fields,
+        constructor,
+        items,
+        name,
+        inherits,
+        ..
+    } = &top_level.0.item
+    {
+        if let Some(constructor) = constructor {
+            let mut fields = fields
+                .iter()
+                .map(|field| Spanned {
+                    item: field.item.decl.name.clone(),
+                    line: field.line,
+                    column: field.column,
+                })
+                .collect::<Vec<_>>();
+
+            if inherits.is_some() {
+                fields.push(Spanned {
+                    line: top_level.0.line,
+                    column: top_level.0.column,
+                    item: Identifier("_super".to_string()),
+                });
+            }
+
+            let mut mutability = constructor.item.body.get_mutability();
+
+            let mut i = 0;
+            while i < mutability.len() {
+                let name = mutability[i].clone();
+                if let Some(method) = find_function_call(items, &name) {
+                    if let Some(body) = &method.item.body {
+                        for entry in body.get_mutability() {
+                            if !mutability.contains(&entry) {
+                                mutability.push(entry);
+                            }
+                        }
+                    }
+                }
+                i += 1;
+            }
+
+            let mut errs = Vec::new();
+
+            for field in &fields {
+                if !mutability.contains(&field.item) {
+                    errs.push(SemanticError {
+                        line: field.line,
+                        column: field.column,
+                        error_message: format!(
+                            "class field `{}.{}` is uninitialized",
+                            name.0, field.item.0
+                        ),
+                    });
+                }
+            }
+
+            if errs.len() > 0 {
+                return Err(errs);
+            }
+        }
+
+        Ok(())
+    } else {
+        Ok(())
+    }
+}
+
+impl<T: GetMutability> GetMutability for Vec<T> {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        self.iter().flat_map(T::get_mutability).collect()
+    }
+}
+
+impl GetMutability for Block {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        let mut items: Vec<Identifier> = self
+            .statements
+            .iter()
+            .flat_map(|v| v.item.get_mutability())
+            .collect();
+
+        if let Some(v) = &self.soft_return {
+            items.append(&mut v.item.get_mutability());
+        }
+
+        items
+    }
+}
+
+impl GetMutability for Statement {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        match self {
+            Statement::Block(body) | Statement::UnsafeBlock(body) => body.get_mutability(),
+            Statement::If {
+                initial,
+                else_if,
+                else_branch,
+            } => {
+                let mut all_sets: Vec<Vec<Identifier>> = Vec::new();
+                all_sets.push(initial.body.get_mutability());
+
+                for branch in else_if {
+                    all_sets.push(branch.body.get_mutability());
+                }
+
+                if let Some(else_block) = else_branch {
+                    all_sets.push(else_block.get_mutability());
+                } else {
+                    return Vec::new();
+                }
+
+                let mut result = all_sets.remove(0);
+                for set in all_sets {
+                    result.retain(|id| set.contains(id));
+                }
+                result
+            }
+            Statement::Loop(body) => body.get_mutability(),
+            Statement::While(branch) => branch.body.get_mutability(),
+            Statement::CStyleFor {
+                body,
+                init,
+                condition,
+                update,
+                ..
+            } => {
+                let mut a = init.get_mutability();
+                a.append(&mut condition.get_mutability());
+                a.append(&mut update.get_mutability());
+                a.append(&mut body.get_mutability());
+                a
+            }
+            Statement::For { body, iterator, .. } => {
+                let mut a = iterator.get_mutability();
+                a.append(&mut body.get_mutability());
+                a
+            }
+            Statement::Match(_, items) => {
+                if items.is_empty() {
+                    return Vec::new();
+                }
+                let mut all_sets: Vec<Vec<Identifier>> = items
+                    .iter()
+                    .map(|item| item.item.get_mutability())
+                    .collect();
+                let mut result = all_sets.remove(0);
+                for set in all_sets {
+                    result.retain(|id| set.contains(id));
+                }
+                result
+            }
+            Statement::VarDecl(stmt) => stmt
+                .init
+                .as_ref()
+                .map(|e| e.get_mutability())
+                .unwrap_or_default(),
+            Statement::Return(expr) => expr
+                .as_ref()
+                .map(|e| e.get_mutability())
+                .unwrap_or_default(),
+            Statement::Break | Statement::Continue => Vec::new(),
+        }
+    }
+}
+
+impl GetMutability for StatementBranch {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        let mut a = self.condition.get_mutability();
+        a.append(&mut self.body.get_mutability());
+        a
+    }
+}
+
+impl GetMutability for MatchItem {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        self.1.get_mutability()
+    }
+}
+
+impl GetMutability for VarDeclStmt {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        self.init
+            .as_ref()
+            .map(|e| e.get_mutability())
+            .unwrap_or_default()
+    }
+}
+
+fn get_self_ref(initial: &Expression, postfixes: &[Postfix]) -> Option<Identifier> {
+    match initial {
+        Expression::Path(v) => {
+            let ident = v.0.first()?.ident.0.as_str();
+            if ident == "self" || ident == "super" {
+                if let Some(Postfix::FieldAccess(field, _)) = postfixes.first() {
+                    if !matches!(postfixes.get(1), Some(Postfix::Call(_))) {
+                        return Some(field.clone());
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    None
+}
+
+fn get_self_method_call(initial: &Expression, postfixes: &[Postfix]) -> Option<Identifier> {
+    match initial {
+        Expression::Path(v) => {
+            let ident = v.0.first()?.ident.0.as_str();
+            if ident == "self" || ident == "super" {
+                if let Some(Postfix::FieldAccess(method, _)) = postfixes.first() {
+                    if matches!(postfixes.get(1), Some(Postfix::Call(_))) {
+                        return Some(method.clone());
+                    }
+                }
+            }
+        }
+        _ => {}
+    }
+    None
+}
+
+impl Expression {
+    fn get_self_ref(&self) -> Option<Identifier> {
+        match self {
+            Self::Fix {
+                initial, postfixes, ..
+            } => get_self_ref(initial, postfixes),
+            _ => None,
+        }
+    }
+}
+
+impl GetMutability for Expression {
+    fn get_mutability(&self) -> Vec<Identifier> {
+        match self {
+            Self::Array(v) => v.get_mutability(),
+            Self::ArrayRepeat(v, i) => {
+                let mut a = v.get_mutability();
+                a.append(&mut i.get_mutability());
+                a
+            }
+            Self::Binary { lhs, op, rhs } => {
+                if mutates_lhs(op) {
+                    let mut a = if let Some(self_ref) = lhs.get_self_ref() {
+                        vec![self_ref]
+                    } else {
+                        lhs.get_mutability()
+                    };
+
+                    a.append(&mut rhs.get_mutability());
+                    a
+                } else {
+                    let mut a = lhs.get_mutability();
+                    a.append(&mut rhs.get_mutability());
+                    a
+                }
+            }
+            Self::Statement(stmt) => stmt.get_mutability(),
+            Self::Fix {
+                initial,
+                prefixes,
+                postfixes,
+            } => {
+                let mut result = Vec::new();
+
+                // &mut self.field / &mut super.field / &mut super pattern
+                if prefixes.iter().any(|p| matches!(p, Prefix::RefMut)) {
+                    if let Some(self_ref) = get_self_ref(initial, postfixes) {
+                        result.push(self_ref);
+                    } else if let Expression::Path(v) = &**initial {
+                        if v.0.first().map_or(false, |s| s.ident.0 == "super") {
+                            result.push(Identifier("_super".to_string()));
+                        }
+                    }
+                }
+
+                // Recurse into all postfix sub-expressions
+                for postfix in postfixes {
+                    match postfix {
+                        Postfix::Call(args) => {
+                            for arg in args {
+                                result.append(&mut arg.get_mutability());
+                            }
+                        }
+                        Postfix::StructCall(fields) => {
+                            for (_, expr) in fields {
+                                if let Some(expr) = expr {
+                                    result.append(&mut expr.get_mutability());
+                                }
+                            }
+                        }
+                        Postfix::Index(expr) => {
+                            result.append(&mut expr.get_mutability());
+                        }
+                        _ => {}
+                    }
+                }
+
+                // Method calls on self: self.method_name(args)
+                if let Some(method) = get_self_method_call(initial, postfixes) {
+                    result.push(method);
+                }
+
+                result
+            }
+            Self::Closure { body, .. } => body.get_mutability(),
+            Self::Literal(_) => Vec::new(),
+            Self::Path(v) => {
+                if v.0.first().map_or(false, |s| s.ident.0 == "super") {
+                    vec![Identifier("_super".to_string())]
+                } else {
+                    Vec::new()
+                }
+            }
+        }
+    }
+}
+
+pub fn mutates_lhs(op: &str) -> bool {
+    matches!(op, "=" | "->")
+}

mist-test/Mist.toml

@@ -1 +1,2 @@
 package = "main.mist"
+packages = []

mist-test/src/app.mist

@@ -1,123 +0,0 @@
-use <super::task>;
-use <super::logger>;
-use <super::event>;
-
-pub class Application {
-    String name;
-
-    Vec<task::Task> tasks;
-    Vec<String> plugins;
-
-    logger::Logger logger;
-
-    bool running;
-    i32 ticks;
-
-    pub constructor(str* name) {
-        self.name = name.to_string();
-        self.tasks = new Vec();
-        self.plugins = new Vec();
-
-        self.logger = new logger::Logger("app");
-
-        self.running = false;
-        self.ticks = 0;
-    }
-
-    pub void boot(self mut*) {
-        self.logger.info("booting application");
-
-        self.running = true;
-
-        self.emit(event::Event::Startup);
-    }
-
-    pub void run(self mut*) {
-        while(self.running) {
-            self.tick();
-
-            if(self.ticks >= 5) {
-                self.shutdown();
-            }
-        }
-    }
-
-    void tick(self mut*) {
-        self.logger.info("tick");
-
-        self.ticks++;
-
-        var task = task::create_task("background-job");
-
-        self.tasks.push(task);
-
-        println!("tasks: {}", self.tasks.len());
-    }
-
-    pub void shutdown(self mut*) {
-        self.emit(event::Event::Shutdown);
-
-        self.logger.warning("shutdown");
-
-        self.running = false;
-    }
-
-    pub void register_plugin(self mut*, String name) {
-        self.plugins.push(name.clone());
-
-        self.emit(event::Event::PluginLoaded(name));
-    }
-
-    void emit(self*, event::Event event) {
-        match(event) {
-            event::Event::Startup => {
-                self.logger.info("startup event");
-            }
-
-            event::Event::Shutdown => {
-                self.logger.info("shutdown event");
-            }
-
-            event::Event::PluginLoaded[name] => {
-                println!("plugin loaded: {}", name);
-            }
-
-            event::Event::TaskExecuted[name] => {
-                println!("task executed: {}", name);
-            }
-
-            event::Event::Error[message] => {
-                self.logger.error(&message);
-            }
-        }
-    }
-}
-
-i32 test_stmt() {
-    if (0 == 0) {
-        0
-    }
-    else {
-        1
-    }
-}
-
-void loops_test() {
-    for (x : 0..10) {
-        println!("{x}");
-    }
-
-    for (var mut i = 0; i < 10; i++) {
-        println!("{i}");
-    }
-
-    var i = 0;
-
-    while (i == 1) {
-        println!("hi");
-    }
-
-    loop {
-        println!("loop!");
-    }
-}

mist-test/src/common/decl_test.mist

@@ -0,0 +1,91 @@
+pub module decl_test;
+
+pub void test_let_basic()
+{
+    let x = 42;
+    assert_eq!(x, 42);
+}
+
+pub void test_let_typed()
+{
+    i32 x = 42;
+    assert_eq!(x, 42);
+    str& s = "hello";
+    assert_eq!(s, "hello");
+    bool b = true;
+    assert_eq!(b, true);
+    f64 f = 3.14;
+    assert_eq!(f, 3.14);
+}
+
+pub void test_let_mut()
+{
+    let mut _x = 42;
+    _x = 100;
+    assert_eq!(_x, 100);
+}
+
+pub void test_let_tuple_destructure()
+{
+    let (a, b) = (10, "hello");
+    assert_eq!(a, 10);
+    assert_eq!(b, "hello");
+}
+
+pub void test_let_nested_tuple()
+{
+    let (a, (b, c)) = (1, (2, 3));
+    assert_eq!(a, 1);
+    assert_eq!(b, 2);
+    assert_eq!(c, 3);
+}
+
+pub void test_let_pattern_irrefutable()
+{
+    let x = 5;
+    let (y, z) = (1, 2);
+    assert_eq!(x, 5);
+    assert_eq!(y, 1);
+    assert_eq!(z, 2);
+}
+
+pub void test_multiple_decls()
+{
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    assert_eq!(a + b + c, 6);
+}
+
+pub void test_let_with_type_and_init()
+{
+    f64 x = 10.0;
+    assert_eq!(x, 10.0);
+}
+
+pub void test_string_literal()
+{
+    let s = "hello, world!";
+    assert_eq!(s.len(), 13);
+}
+
+pub void test_let_bool()
+{
+    let t = true;
+    let f = false;
+    assert_eq!(t, !f);
+}
+
+pub void run_tests()
+{
+    test_let_basic();
+    test_let_typed();
+    test_let_mut();
+    test_let_tuple_destructure();
+    test_let_nested_tuple();
+    test_let_pattern_irrefutable();
+    test_multiple_decls();
+    test_let_with_type_and_init();
+    test_string_literal();
+    test_let_bool();
+}

mist-test/src/common/expr_test.mist

@@ -0,0 +1,177 @@
+pub module expr_test;
+
+pub void test_literals()
+{
+    assert_eq!(42, 42);
+    assert_eq!(3.14, 3.14);
+    assert_eq!(true, true);
+    assert_eq!(false, false);
+    assert_eq!("hello", "hello");
+}
+
+pub void test_tuples()
+{
+    let t = (1, true, "three");
+    assert_eq!(t.0, 1);
+    assert_eq!(t.1, true);
+    assert_eq!(t.2, "three");
+}
+
+pub void test_arrays()
+{
+    let arr = [1, 2, 3];
+    assert_eq!(arr[0], 1);
+    assert_eq!(arr[1], 2);
+    assert_eq!(arr[2], 3);
+}
+
+pub void test_array_repeat()
+{
+    let arr = [0; 5];
+    assert_eq!(arr[0], 0);
+    assert_eq!(arr[4], 0);
+    assert_eq!(arr.len(), 5);
+}
+
+pub void test_binary_arith()
+{
+    assert_eq!(10 + 5, 15);
+    assert_eq!(10 - 5, 5);
+    assert_eq!(10 * 5, 50);
+    assert_eq!(10 / 5, 2);
+    assert_eq!(10 % 3, 1);
+}
+
+pub void test_binary_cmp()
+{
+    assert_eq!(5 < 10, true);
+    assert_eq!(10 <= 10, true);
+    assert_eq!(10 > 5, true);
+    assert_eq!(10 >= 10, true);
+    assert_eq!(5 == 5, true);
+    assert_eq!(5 != 10, true);
+}
+
+pub void test_binary_logic()
+{
+    assert_eq!(true && true, true);
+    assert_eq!(true && false, false);
+    assert_eq!(true || false, true);
+    assert_eq!(false || false, false);
+}
+
+pub void test_binary_bit()
+{
+    assert_eq!(5 & 3, 1);
+    assert_eq!(5 | 3, 7);
+    assert_eq!(5 ^ 3, 6);
+    assert_eq!(1 << 2, 4);
+    assert_eq!(4 >> 1, 2);
+}
+
+pub void test_prefix()
+{
+    let x = 42;
+    assert_eq!(-x, -42);
+    assert_eq!(!true, false);
+    assert_eq!(!false, true);
+}
+
+pub void test_ref_deref()
+{
+    let x = 42;
+    let r = &x;
+    assert_eq!(*r, 42);
+}
+
+pub void test_postfix_inc_dec()
+{
+    let mut x = 5;
+    x++;
+    assert_eq!(x, 6);
+    x--;
+    assert_eq!(x, 5);
+}
+
+pub void test_as_cast()
+{
+    let x = 42;
+    assert_eq!(x as f64, 42.0);
+}
+
+pub void test_closure()
+{
+    let add = (a, b) => a + b;
+    assert_eq!(add(2, 3), 5);
+}
+
+pub void test_block_expr()
+{
+    let x = {
+        let y = 10;
+        y + 5
+    };
+    assert_eq!(x, 15);
+}
+
+pub void test_if_expr()
+{
+    let x = if true {
+        1
+    } else {
+        2
+    };
+    assert_eq!(x, 1);
+    let y = if false {
+        1
+    } else {
+        2
+    };
+    assert_eq!(y, 2);
+}
+
+pub void test_range_expr()
+{
+    let r = 0 .. 5;
+    let mut count = 0;
+    for i in r {
+        count++;
+    }
+    assert_eq!(count, 5);
+}
+
+pub void test_binary_assign()
+{
+    let mut x = 10;
+    x += 5;
+    assert_eq!(x, 15);
+    x -= 3;
+    assert_eq!(x, 12);
+    x *= 2;
+    assert_eq!(x, 24);
+    x /= 4;
+    assert_eq!(x, 6);
+    x %= 4;
+    assert_eq!(x, 2);
+}
+
+pub void run_tests()
+{
+    test_literals();
+    test_tuples();
+    test_arrays();
+    test_array_repeat();
+    test_binary_arith();
+    test_binary_cmp();
+    test_binary_logic();
+    test_binary_bit();
+    test_prefix();
+    test_ref_deref();
+    test_postfix_inc_dec();
+    test_as_cast();
+    test_closure();
+    test_block_expr();
+    test_if_expr();
+    test_range_expr();
+    test_binary_assign();
+}

mist-test/src/common/package.mist

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

mist-test/src/common/statement_test.mist

@@ -0,0 +1,179 @@
+pub module statement_test;
+
+pub void test_var_decl()
+{
+    let x = 42;
+    assert_eq!(x, 42);
+    i32 y = 10;
+    assert_eq!(y, 10);
+    str& name = "mist";
+    assert_eq!(name, "mist");
+}
+
+pub void test_var_decl_with_init()
+{
+    let mut x = 0;
+    x = 5;
+    assert_eq!(x, 5);
+}
+
+pub void test_if_statement()
+{
+    let mut x = 0;
+    if true {
+        x = 1;
+    }
+    assert_eq!(x, 1);
+    if false {
+        x = 2;
+    } else {
+        x = 3;
+    }
+    assert_eq!(x, 3);
+}
+
+pub void test_if_else_if()
+{
+    let mut x = 0;
+    if x == 1 {
+        x = 10;
+    } else if x == 0 {
+        x = 20;
+    } else {
+        x = 30;
+    }
+    assert_eq!(x, 20);
+}
+
+pub void test_while_loop()
+{
+    let mut count = 0;
+    while count < 5 {
+        count++;
+    }
+    assert_eq!(count, 5);
+}
+
+pub void test_for_loop()
+{
+    let mut sum = 0;
+    for i in 0 .. 4 {
+        sum += i;
+    }
+    assert_eq!(sum, 6);
+}
+
+pub void test_loop_stmt()
+{
+    let mut count = 0;
+    loop {
+        count++;
+        if count >= 3 {
+            break;
+        }
+    }
+    assert_eq!(count, 3);
+}
+
+pub void test_break_continue()
+{
+    let mut sum = 0;
+    for i in 0 .. 10 {
+        if i % 2 == 0 {
+            continue;
+        }
+        if i >= 7 {
+            break;
+        }
+        sum += i;
+    }
+    assert_eq!(sum, 1 + 3 + 5);
+}
+
+pub i32 test_return()
+{
+    return 42;
+}
+
+pub void test_block_scope()
+{
+    let x = {
+        let inner = 10;
+        inner + 5
+    };
+    assert_eq!(x, 15);
+}
+
+pub void test_match_literal()
+{
+    let x = 2;
+    let result;
+    match x {
+        1 => {
+            result = 10;
+        }
+        2 => result = 20,
+        3 => result = 30,
+        _ => panic!(),
+    }
+    assert_eq!(result, 20);
+}
+
+pub void test_match_or_pattern()
+{
+    let x = 1;
+    i32 result;
+    match x {
+        1 | 2 => {
+            result = 100;
+        }
+        3 => {
+            result = 200;
+        }
+        _ => panic!(),
+    }
+    assert_eq!(result, 100);
+}
+
+pub void test_match_default()
+{
+    let x = 99;
+    let result;
+    match x {
+        1 => {
+            result = 10;
+        }
+        y => {
+            result = y;
+        }
+    }
+    assert_eq!(result, 99);
+}
+
+pub void test_for_with_pattern_destructure()
+{
+    let pairs = [(1, "a"), (2, "b")];
+    let mut keys = 0;
+    for (k, _) in pairs {
+        keys += k;
+    }
+    assert_eq!(keys, 3);
+}
+
+pub void run_tests()
+{
+    test_var_decl();
+    test_var_decl_with_init();
+    test_if_statement();
+    test_if_else_if();
+    test_while_loop();
+    test_for_loop();
+    test_loop_stmt();
+    test_break_continue();
+    assert_eq!(test_return(), 42);
+    test_block_scope();
+    test_match_literal();
+    test_match_or_pattern();
+    test_match_default();
+    test_for_with_pattern_destructure();
+}

mist-test/src/common/types_test.mist

@@ -0,0 +1,65 @@
+pub module types_test;
+
+pub void test_integer_type() {
+    i32 x = 42;
+    assert_eq!(x, 42);
+}
+
+pub void test_float_type() {
+    f64 x = 3.14;
+    assert_eq!(x, 3.14);
+}
+
+pub void test_bool_type() {
+    bool x = true;
+    assert_eq!(x, true);
+    bool y = false;
+    assert_eq!(y, false);
+}
+
+pub void test_string_type() {
+    str& s = "hello";
+    assert_eq!(s, "hello");
+}
+
+pub void test_tuple_type() {
+    (i32, str&) t = (42, "answer");
+    assert_eq!(t.0, 42);
+    assert_eq!(t.1, "answer");
+}
+
+pub void test_ref_type() {
+    i32 x = 42;
+    i32& r = &x;
+    assert_eq!(*r, 42);
+}
+
+pub void test_mut_ref_type() {
+    let mut x = 42;
+    i32 mut& r = &mut x;
+    *r = 100;
+    assert_eq!(x, 100);
+}
+
+pub void test_void_type() {
+}
+
+i32 add(i32 a, i32 b) {
+    a + b
+}
+
+pub void test_fn_return_type() {
+    assert_eq!(add(3, 4), 7);
+}
+
+pub void run_tests() {
+    test_integer_type();
+    test_float_type();
+    test_bool_type();
+    test_string_type();
+    test_tuple_type();
+    test_ref_type();
+    test_mut_ref_type();
+    test_void_type();
+    test_fn_return_type();
+}

mist-test/src/event.mist

@@ -1,7 +0,0 @@
-pub enum Event {
-    Startup,
-    Shutdown,
-    TaskExecuted[String],
-    PluginLoaded[String],
-    Error[String],
-}

mist-test/src/items/attribute_test.mist

@@ -0,0 +1,29 @@
+pub module attribute_test;
+
+#[derive(Debug)]
+pub struct Debuggable
+{
+    i32 value,
+}
+
+pub void test_derive_attribute()
+{
+    let d = Debuggable {
+        value: 42,
+    };
+    assert_eq!(d.value, 42);
+}
+
+#[allow(unused_variables)]
+pub void test_allow_attribute()
+{
+    let x = 42;
+    let y = "unused";
+    assert_eq!(x, 42);
+}
+
+pub void run_tests()
+{
+    test_derive_attribute();
+    test_allow_attribute();
+}

mist-test/src/items/class_test.mist

@@ -0,0 +1,68 @@
+pub module class_test;
+
+pub class Animal
+{
+    pub String name;
+
+    constructor() 
+    {
+        self.name = "Rex".to_string();
+    }
+
+    pub String speak(&self)
+    {
+        "Unknown".to_string()
+    }
+
+    pub void test_speak<'a>(&'a self)
+    {
+        assert_eq!(self.speak(), "Woof!");
+    }
+
+    pub void static_method()
+    {
+    }
+}
+
+pub class Mammal : Animal
+{
+    constructor() 
+    {
+        super = Super::new();
+    }
+
+    pub void args_test(&self, i32 x, str& y)
+    {
+        assert_eq!(x, 10);
+        assert_eq!(y, "hello");
+    }
+}
+
+pub class Dog : Mammal
+{
+    constructor() 
+    {
+        super = Super::new();
+    }
+
+    pub String speak(&self) override(Animal)
+    {
+        "Woof!".to_string()
+    }
+
+    impl std::fmt::Display
+    {
+        Result<(), std::fmt::Error> fmt(&self, std::fmt::Formatter<'_> mut& f)
+        {
+            write!(f, "🐾 {}", self.name)
+        }
+    }
+}
+
+pub void run_tests()
+{
+    let dawg = Dog::new();
+    dawg.args_test(10, "hello");
+    dawg.test_speak();
+    assert_eq!(format!("{dawg}"), "🐾 Rex");
+}

mist-test/src/items/enum_test.mist

@@ -0,0 +1,94 @@
+pub module enum_test;
+
+enum OptionInt
+{
+    None,
+    Some(i32),
+}
+
+pub void test_enum_named()
+{
+    let x = OptionInt::None;
+    match x {
+        OptionInt::None => {
+            assert_eq!(1, 1);
+        }
+        OptionInt::Some(_) => {
+            assert_eq!(0, 1);
+        }
+    }
+}
+
+pub void test_enum_tuple()
+{
+    let x = OptionInt::Some(42);
+    match x {
+        OptionInt::None => {
+            assert_eq!(0, 1);
+        }
+        OptionInt::Some(v) => {
+            assert_eq!(v, 42);
+        }
+    }
+}
+
+enum Shape
+{
+    Circle {i32 radius},
+    Rect {i32 w, i32 h},
+}
+
+pub void test_enum_struct()
+{
+    let c = Shape::Circle {
+        radius: 5,
+    };
+    match c {
+        Shape::Circle {radius} => {
+            assert_eq!(radius, 5);
+        }
+        Shape::Rect {..} => {
+            assert_eq!(0, 1);
+        }
+    }
+    let r = Shape::Rect {
+        w: 3,
+        h: 4,
+    };
+    match r {
+        Shape::Circle {..} => {
+            assert_eq!(0, 1);
+        }
+        Shape::Rect {w, h} => {
+            assert_eq!(w * h, 12);
+        }
+    }
+}
+
+enum Color
+{
+    Red,
+    Green,
+    Blue,
+}
+
+pub void test_enum_eq()
+{
+    let c = Color::Red;
+    match c {
+        Color::Red => {
+            assert_eq!(1, 1);
+        }
+        _ => {
+            assert_eq!(0, 1);
+        }
+    }
+}
+
+pub void run_tests()
+{
+    test_enum_named();
+    test_enum_tuple();
+    test_enum_struct();
+    test_enum_eq();
+}

mist-test/src/items/function_test.mist

@@ -0,0 +1,82 @@
+pub module function_test;
+
+void greet()
+{
+    let mut x = 1;
+    x++;
+}
+
+pub void test_basic_function()
+{
+    greet();
+}
+
+i32 add(i32 a, i32 b)
+{
+    a + b
+}
+
+pub void test_fn_params()
+{
+    assert_eq!(add(2, 3), 5);
+}
+
+pub i32 test_fn_return()
+{
+    42
+}
+
+pub i32 test_fn_early_return()
+{
+    return 100;
+    0
+}
+
+pub i32 test_fn_mut_param(i32 mut x)
+{
+    x = x + 10;
+    x
+}
+
+pub void test_method_call()
+{
+    let s = "hello";
+    assert_eq!(s.len(), 5);
+    assert_eq!(s.to_uppercase(), "HELLO");
+}
+
+i32 triple(i32 x)
+{
+    add(x, add(x, x))
+}
+
+pub void test_nested_fn_calls()
+{
+    assert_eq!(triple(5), 15);
+}
+
+i32 factorial(i32 n)
+{
+    if n <= 1 {
+        1
+    } else {
+        n * factorial(n - 1)
+    }
+}
+
+pub void test_recursive_fn()
+{
+    assert_eq!(factorial(5), 120);
+}
+
+pub void run_tests()
+{
+    test_basic_function();
+    test_fn_params();
+    assert_eq!(test_fn_return(), 42);
+    assert_eq!(test_fn_early_return(), 100);
+    assert_eq!(test_fn_mut_param(5), 15);
+    test_method_call();
+    test_nested_fn_calls();
+    test_recursive_fn();
+}

mist-test/src/items/impl_test.mist

@@ -0,0 +1,80 @@
+pub module impl_test;
+
+struct Vector2
+{
+    i32 x,
+    i32 y,
+}
+
+impl Vector2
+{
+    pub i32 magnitude(&self)
+    {
+        self.x * self.x + self.y * self.y
+    }
+}
+
+pub void test_inherent_impl()
+{
+    let v = Vector2 {
+        x: 3,
+        y: 4,
+    };
+    assert_eq!(v.magnitude(), 25);
+}
+
+trait Display
+{
+    String display(&self);
+}
+
+impl Display for Vector2
+{
+    String display(&self)
+    {
+        format!("({}, {})", self.x, self.y)
+    }
+}
+
+pub void test_trait_impl_block()
+{
+    let v = Vector2 {
+        x: 1,
+        y: 2,
+    };
+    let s = v.display();
+    assert_eq!(s.len() > 0, true);
+}
+
+impl Vector2
+{
+    pub Vector2 add(&self, Vector2 other)
+    {
+        Vector2 {
+            x: self.x + other.x,
+            y: self.y + other.y,
+        }
+    }
+}
+
+pub void test_multiple_impls()
+{
+    let a = Vector2 {
+        x: 1,
+        y: 2,
+    };
+    let b = Vector2 {
+        x: 3,
+        y: 4,
+    };
+    let c = a.add(b);
+    assert_eq!(c.x, 4);
+    assert_eq!(c.y, 6);
+}
+
+pub void run_tests()
+{
+    test_inherent_impl();
+    test_trait_impl_block();
+    test_multiple_impls();
+}

mist-test/src/items/struct_test.mist

@@ -0,0 +1,68 @@
+pub module struct_test;
+
+struct Point
+{
+    i32 x,
+    i32 y,
+}
+
+pub void test_struct_create_access()
+{
+    let p = Point {
+        x: 10,
+        y: 20,
+    };
+    assert_eq!(p.x, 10);
+    assert_eq!(p.y, 20);
+}
+
+pub void test_struct_mut_field()
+{
+    let mut p = Point {
+        x: 1,
+        y: 2,
+    };
+    p.x = 100;
+    assert_eq!(p.x, 100);
+}
+
+pub void test_struct_destructure()
+{
+    let p = Point {
+        x: 3,
+        y: 4,
+    };
+    let Point {x, y} = p;
+    assert_eq!(x, 3);
+    assert_eq!(y, 4);
+}
+
+struct Line
+{
+    Point start,
+    Point end,
+}
+
+pub void test_struct_nested()
+{
+    let l = Line {
+        start: Point {
+            x: 0,
+            y: 0,
+        },
+        end: Point {
+            x: 5,
+            y: 10,
+        },
+    };
+    assert_eq!(l.start.x, 0);
+    assert_eq!(l.end.y, 10);
+}
+
+pub void run_tests()
+{
+    test_struct_create_access();
+    test_struct_mut_field();
+    test_struct_destructure();
+    test_struct_nested();
+}

mist-test/src/items/trait_test.mist

@@ -0,0 +1,55 @@
+pub module trait_test;
+
+trait Speak
+{
+    String speak(&self);
+}
+
+trait Greet : Speak
+{
+    String greet(&self);
+}
+
+struct Dog
+{
+    String name,
+}
+
+impl Speak for Dog
+{
+    String speak(&self)
+    {
+        "woof".to_string()
+    }
+}
+
+impl Greet for Dog
+{
+    String greet(&self)
+    {
+        "hello".to_string()
+    }
+}
+
+pub void test_trait_impl()
+{
+    let d = Dog {
+        name: "Rex".to_string(),
+    };
+    assert_eq!(d.speak(), "woof");
+}
+
+pub void test_trait_with_requirement()
+{
+    let d = Dog {
+        name: "Buddy".to_string(),
+    };
+    assert_eq!(d.speak(), "woof");
+    assert_eq!(d.greet(), "hello");
+}
+
+pub void run_tests()
+{
+    test_trait_impl();
+    test_trait_with_requirement();
+}

mist-test/src/logger.mist

@@ -1,72 +0,0 @@
-use <std::fmt::Formatter>;
-use <std::fmt>;
-
-pub trait TestLogging<T: fmt::Display>: fmt::Display {
-    String get(self*);
-}
-
-pub enum LogLevel {
-    Info,
-    Warning,
-    Error,
-}
-
-impl fmt::Display for LogLevel {
-    fmt::Result fmt(self*, Formatter<'_> mut* f) {
-        match (self) {
-            LogLevel::Info => write!(f, "[INFO]");
-
-            LogLevel::Warning => write!(f, "[WARN]");
-
-            LogLevel::Error => write!(f, "[ERROR]");
-        }
-    }
-}
-
-impl TestLogging<LogLevel> for LogLevel {
-    String get(self*) {
-        return format!("{self}");
-    }
-}
-
-pub class Logger {
-    String prefix;
-
-    pub constructor(str* prefix) {
-        self.prefix = prefix.to_string();
-    }
-
-    pub void info(self*, str* message) {
-        self.log(LogLevel::Info, message);
-    }
-
-    pub void warning(self*, str* message) {
-        self.log(LogLevel::Warning, message);
-    }
-
-    pub void error(self*, str* message) {
-        self.log(LogLevel::Error, message);
-    }
-
-    void log(self*, LogLevel level, str* message) {
-        match(level) {
-            LogLevel::Info => {
-                println!("{level} {} {}", self.prefix, message);
-            }
-
-            LogLevel::Warning => {
-                println!("{} {} {}", level.get(), self.prefix, message);
-            }
-
-            LogLevel::Error => {
-                println!("{level} {} {}", self.prefix, message);
-            }
-        }
-    }
-
-    impl fmt::Display {
-        fmt::Result fmt(self*, Formatter<'_> mut* f) {
-            write!(f, "logger ({})", self.prefix)
-        }
-    }
-}

mist-test/src/main.mist

@@ -1,22 +1,18 @@
-void main() {
-    var mut app_instance = new app::Application("mist-app");
-
-    app_instance.boot();
-    app_instance.run();
-}
-
-void do_stuff() {
-    vec!(1, 2, 3).into_iter().map(Option<i32> |var v| {Some(v)}).collect::<Vec<_>>();
-
-    if (43==69) testing1();
-}
-
-i32 testing1() {
-
-    i32 v = if (0 == 0) {
-        0
-    } else {
-        1
-    };
-    v
+void main()
+{
+    println!("running common tests...");
+    common::test_package();
+    common::expr_test::run_tests();
+    common::statement_test::run_tests();
+    common::decl_test::run_tests();
+    common::types_test::run_tests();
+    println!("running items tests...");
+    items::function_test::run_tests();
+    items::struct_test::run_tests();
+    items::enum_test::run_tests();
+    items::class_test::run_tests();
+    items::trait_test::run_tests();
+    items::impl_test::run_tests();
+    items::attribute_test::run_tests();
+    println!("\x1b[32m\nAll tests passed!\x1b[0m");
 }

mist-test/src/plugin.mist

@@ -1,16 +0,0 @@
-pub struct PluginInfo {
-    pub String name,
-    pub String version,
-}
-
-pub class PluginRegistry<T> {
-    T plugins;
-
-    pub constructor(T plugins) {
-        self.plugins = plugins;
-    }
-
-    pub T plugins(self) {
-        return self.plugins;
-    }
-}

mist-test/src/task.mist

@@ -1,20 +0,0 @@
-pub enum TaskState {
-    Pending,
-    Running,
-    Finished,
-    Failed,
-}
-
-pub struct Task {
-    pub String name,
-    pub TaskState state,
-    pub i32 executions,
-}
-
-pub Task create_task(str* name) {
-    Task {
-        name: name.to_string(),
-        state: TaskState::Pending,
-        executions: 0,
-    }
-}

src/analyzer.mist

@@ -1,5 +1,3 @@
-use <mist_analyzer>;
-
 void main() {
     mist_analyzer::start();
 }

src/main.mist

@@ -1,31 +1,31 @@
-use <std::process>;
-use <std::env>;
-use <std::fs>;
-use <mist_api::builder>;
-use <mist_api::transpiler>;
+use std::process;
+use std::env;
+use std::fs;
+use mist_api::builder;
+use mist_api::transpiler;
 
 void main() {
     Vec<String> args = env::args().collect();
 
-    if (args.len() < 2) {
+    if args.len() < 2 {
         print_usage();
         process::exit(1);
     }
 
-    match (args[1].as_str()) {
+    match args[1].as_str() {
         "run" | "build" | "check" | "r" | "b" | "c" => {
-            var root = transpiler::build(false);
+            let root = transpiler::transpile();
 
             println!("");
 
-            if (builder::build(args, root)) {
+            if builder::build(args, root) {
                 println!("\x1b[32m\nBuild successful\x1b[0m");
             } else {
                 println!("\x1b[31m\nBuild failed\x1b[0m");
             }
         }
         "transpile" | "t" => {
-            transpiler::build(args.get(2).is_some());
+            transpiler::transpile();
         }
         "init" => {
             init_project(args);
@@ -69,7 +69,7 @@ void print_usage() {
 void init_project(Vec<String> mut args) {
     args.remove(0);
 
-    new process::Command("cargo")
+    process::Command::new("cargo")
         .args(args)
         .stdout(process::Stdio::inherit())
         .stderr(process::Stdio::inherit())
@@ -79,12 +79,12 @@ void init_project(Vec<String> mut args) {
 
     bool is_lib = fs::metadata("src/lib.rs").is_ok();
 
-    if (is_lib) {
+    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");
+        fs::write("src/lib.mist", "fn 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");
+        fs::write("src/main.mist", "fn main() {\n    println!(\"Hello, World!\");\n}\n").expect("Failed to create src/main.mist");
     }
 
     inject_mist_target(is_lib);
@@ -95,7 +95,7 @@ void init_project(Vec<String> mut args) {
 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) {
+    str& inject = if is_lib {
         "\n[lib]\nname = \"my_lib\"\npath = \".mist/src/lib.rs\"\n"
     } else {
         "\n[[bin]]\nname = \"my_bin\"\npath = \".mist/src/main.rs\"\n"