feat(heap): Component based heap

.editorconfig

@@ -0,0 +1,3 @@
+[*.{rs}]
+indent_style = space
+indent_size = 4

Cargo.toml

@@ -1,8 +1,7 @@
 [workspace]
 members = [
-    "parser",
+    "nova_cli",
+    "nova_vm",
     "common",
-		"tokenizer",
-    "ast",
     "wasm"
 ]

code.js

@@ -0,0 +1 @@
+var asd = "foobar"

parser/Cargo.toml → nova_cli/Cargo.toml

@@ -1,8 +1,12 @@
 [package]
-name = "parser"
+name = "nova_cli"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+clap = { version = "4.3", features = ["derive"] }
+oxc_parser = "0.0.6"
+oxc_ast = "0.0.6"
+nova_vm = { path = "../nova_vm" }

nova_cli/src/main.rs

@@ -0,0 +1,64 @@
+use clap::{Parser as ClapParser, Subcommand};
+use nova_vm::{heap::Heap, VM};
+use oxc_ast::SourceType;
+use oxc_parser::Parser;
+
+/// A JavaScript engine
+#[derive(Debug, ClapParser)] // requires `derive` feature
+#[command(name = "nova")]
+#[command(about = "A JavaScript engine", long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Debug, Subcommand)]
+enum Command {
+    /// Parses a file and logs out the AST
+    Parse {
+        /// The path of the file to parse
+        path: String,
+    },
+
+    /// Evaluates a file
+    Eval {
+        /// The file to evaluate
+        path: String,
+    },
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Cli::parse();
+
+    match args.command {
+        Command::Parse { path } => {
+            let file = std::fs::read_to_string(path)?;
+            let allocator = Default::default();
+            let source_type: SourceType = Default::default();
+            let parser = Parser::new(&allocator, &file, source_type.with_typescript(false));
+            let result = parser.parse();
+
+            println!("{:?}", result.program);
+        }
+        Command::Eval { path } => {
+            let file = std::fs::read_to_string(path)?;
+            let allocator = Default::default();
+            let source_type: SourceType = Default::default();
+            let parser = Parser::new(&allocator, &file, source_type.with_typescript(false));
+            let result = parser.parse();
+
+            let mut vm = VM {
+                source: &file,
+                pc: 0,
+                instructions: Vec::new(),
+                heap: Heap::new(),
+            };
+
+            vm.load_program(result.program);
+            println!("{:?}", vm.instructions);
+            vm.interpret();
+        }
+    }
+
+    Ok(())
+}

ast/Cargo.toml → nova_vm/Cargo.toml

@@ -1,9 +1,12 @@
 [package]
-name = "ast"
+name = "nova_vm"
 version = "0.1.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-serde = { version = "1.0.152", features = ["derive"] }
+gc = { version = "0.4", features = ["derive"] }
+wtf8 = "0.1"
+oxc_parser = "0.0.6"
+oxc_ast = "0.0.6"

nova_vm/src/dyn_ObjectHeapData

@@ -0,0 +1,40 @@
+pub trait ObjectHeapData: Trace + Debug {
+    fn get_prototype_of(&self, heap: &mut Heap) -> JsResult<Option<ObjectIndex>>;
+    fn set_prototype_of(&self, heap: &mut Heap, prototype: Option<ObjectIndex>) -> JsResult<bool>;
+    fn is_extensible(&self, heap: &mut Heap) -> JsResult<bool>;
+    fn prevent_extensions(&self, heap: &mut Heap) -> JsResult<bool>;
+    fn get_own_property(
+        &self,
+        heap: &mut Heap,
+        key: PropertyKey,
+    ) -> JsResult<Option<PropertyDescriptor>>;
+    fn define_own_property(
+        &self,
+        heap: &mut Heap,
+        key: PropertyKey,
+        descriptor: PropertyDescriptor,
+    ) -> JsResult<bool>;
+    fn has_property(&self, heap: &mut Heap, key: PropertyKey) -> JsResult<bool>;
+    fn get(&self, heap: &mut Heap, key: PropertyKey, receiver: &Value) -> JsResult<Value>;
+    fn set(
+        &self,
+        heap: &mut Heap,
+        key: PropertyKey,
+        value: Value,
+        receiver: &Value,
+    ) -> JsResult<bool>;
+    fn delete(&self, heap: &mut Heap, key: PropertyKey) -> JsResult<bool>;
+    fn own_property_keys(&self, heap: &mut Heap) -> JsResult<Vec<PropertyKey>>;
+
+    // Tracing helpers
+    fn get_strong_references(&self) -> Vec<Value>;
+    fn get_weak_references(&self) -> Vec<Value>;
+}
+
+pub trait FunctionHeapData: ObjectHeapData {
+    fn call(&self, this: &Value, args: &[Value]) -> JsResult<Value>;
+}
+
+pub trait ConstructorHeapData: FunctionHeapData {
+    fn construct(&self, args: &[Value], target: ObjectIndex) -> JsResult<Value>;
+}