feat(nova_vm): Reorganize folder structure

README.md

@@ -1,7 +1,9 @@
 ## Warning: This project is a Work In Progress, and is very far from being suitable for use
 
-Nova is a [JavaScript](https://tc39.es/ecma262) and [WebAssembly](https://webassembly.org) engine written in Rust.
+Nova is a [JavaScript](https://tc39.es/ecma262) and
+[WebAssembly](https://webassembly.org) engine written in Rust.
 
-The engine is exposed as a library with an API for implementation in Rust projects which themselves must serve as a runtime for JavaScript code.
+The engine is exposed as a library with an API for implementation in Rust
+projects which themselves must serve as a runtime for JavaScript code.
 
 The core of our team is on our [Discord server](https://discord.gg/RTrgJzXKUM).

code.js

@@ -1 +1 @@
-var asd = "foobar"
+var asd = "foobar";

nova_cli/src/main.rs

@@ -44,7 +44,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             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 _result = parser.parse();
 
             // let mut vm = VM {
             //     source: &file,

nova_vm/README.md

@@ -0,0 +1,21 @@
+## Project structure
+
+The Nova VM source structure is as follows:
+
+1. The `ecmascript` folder contains all code relating to the ECMAScript
+   specification.
+1. The `engine` folder contains Nova engine specific code such as bytecode.
+1. The `heap` folder contains the setup for the heap of the VM and the direct
+   APIs to work with it.
+
+### ECMAScript folder structure
+
+The ECMAScript folder will have its own READMEs to better describe various
+details of the structure but the basic idea is to stay fairly close to the
+ECMAScript specification text and its structure.
+
+As an example, the `ecmascript/types` folder corresponds to the specification's
+section 6, `ECMAScript Data Types and Values`. That section has two subsections,
+6.1 `ECMASCript Language Types` and 6.2 `ECMAScript Specification Types`, which
+then correspond to the `ecmascript/types/language` and `ecmascript/types/spec`
+folders respectively.

nova_vm/src/ecmascript.rs

@@ -0,0 +1,4 @@
+pub mod builtins;
+pub mod execution;
+pub mod scripts_and_modules;
+pub mod types;

nova_vm/src/ecmascript/README.md

@@ -0,0 +1,50 @@
+## ECMAScript
+
+This folder contains the code for things mentioned directly in the
+[ECMAScript language specification](https://tc39.es/ecma262/). As much as is
+reasonable, the structure within this folder should be similar to the
+specification text and code should reuse terms from the specification directly.
+
+### Crossreferencing
+
+#### 6. ECMAScript Data Types and Values
+
+Found in the [`types`](./types/) folder.
+
+#### 7. Abstract operations
+
+Currently mostly found as methods on `Value`.
+
+Maybe move to [`abstract_operations`](./abstract_operation)?
+
+#### 8. Syntax-Directed Operations
+
+This is more about the parsing so I am not sure if this needs to be in the
+engine at all.
+
+If this ends up being needed then it will be in a [`syntax`](./syntax/) folder.
+
+#### 9. Executable Code and Execution Contexts
+
+Found in the [`execution`](./execution/) folder.
+
+#### 10. Ordinary and Exotic Objects Behaviours
+
+Currently mostly found in `builtins` but maybe move to
+[`behaviours`](./behaviours)?
+
+On the other hand, this part of the spec also contains the subsection 10.3
+Built-in Function Objects and various other built-in related things so it might
+be okay to keep this in `builtins` in an inline sort of way.
+
+#### 11-15. ECMAScript Language, and 18. Error Handling and Language Extensions
+
+This is all syntax (and then some) and will not be found in the engine.
+
+#### 16. ECMAScript Language: Scripts and Modules
+
+Found in the [`scripts_and_modules`](./scripts_and_modules/) folder.
+
+#### 18. ECMAScript Standard Built-in Objects, and 19-28.
+
+Should be found in the [`builtins`](./builtins/) folder.

nova_vm/src/builtins/array.rs → nova_vm/src/ecmascript/builtins/array.rs

@@ -1,5 +1,5 @@
 use super::{create_builtin_function, ArgumentsList, Behaviour, Builtin, BuiltinFunctionArgs};
-use crate::{
+use crate::ecmascript::{
     execution::{Agent, JsResult},
     types::{Object, Value},
 };
@@ -21,9 +21,9 @@ impl Builtin for ArrayConstructor {
 
 impl ArrayConstructor {
     fn behaviour(
-        agent: &mut Agent,
-        this_value: Value,
-        arguments: ArgumentsList,
+        _agent: &mut Agent,
+        _this_value: Value,
+        _arguments: ArgumentsList,
     ) -> JsResult<Value> {
         todo!();
     }

nova_vm/src/builtins/builtin_function.rs → nova_vm/src/ecmascript/builtins/builtin_function.rs

@@ -1,8 +1,9 @@
 use crate::{
-    execution::{Agent, Intrinsics, JsResult, Realm, RealmIdentifier},
+    ecmascript::{
+        execution::{Agent, JsResult, RealmIdentifier},
+        types::{Function, Object, PropertyDescriptor, Value},
+    },
     heap::CreateHeapData,
-    types::{Function, Object, PropertyDescriptor, Value},
-    Heap,
 };
 
 #[derive(Debug)]
@@ -53,20 +54,16 @@ impl<'a, 'ctx: 'a, 'host: 'ctx> BuiltinFunctionArgs<'a, 'ctx, 'host> {
 /// https://tc39.es/ecma262/#sec-createbuiltinfunction
 pub fn create_builtin_function<'a, 'b: 'a>(
     agent: &mut Agent<'b, 'b>,
-    behaviour: Behaviour,
+    _behaviour: Behaviour,
     args: BuiltinFunctionArgs<'a, 'b, 'b>,
 ) -> Function {
     // 1. If realm is not present, set realm to the current Realm Record.
     let realm_id = args.realm.unwrap_or(agent.current_realm_id());
 
     // 2. If prototype is not present, set prototype to realm.[[Intrinsics]].[[%Function.prototype%]].
-    let prototype = args.prototype.unwrap_or_else(|| {
-        agent
-            .get_realm(realm_id)
-            .intrinsics()
-            .function_prototype()
-            .into()
-    });
+    let prototype = args
+        .prototype
+        .unwrap_or_else(|| agent.get_realm(realm_id).intrinsics().function_prototype());
     let heap = &mut agent.heap;
 
     // TODO: Steps 3-4
@@ -83,7 +80,7 @@ pub fn create_builtin_function<'a, 'b: 'a>(
     // 8. Set func.[[Realm]] to realm.
     // NOTE: Heap data is implicitly attached to the Realm so I don't think
     //       this matters.
-    let object = heap.create_object_with_prototype(prototype);
+    let _object = heap.create_object_with_prototype(prototype);
 
     // 9. Set func.[[InitialName]] to null.
     // TODO: This is non-standard.
@@ -103,15 +100,15 @@ pub fn create_builtin_function<'a, 'b: 'a>(
     Function(func)
 }
 
-pub fn define_builtin_function<'a, 'b>(
+pub fn define_builtin_function<'b>(
     agent: &mut Agent<'b, 'b>,
-    object: Object,
-    name: &'a str,
+    _object: Object,
+    name: &str,
     behaviour: RegularFn,
     length: u32,
     realm: RealmIdentifier<'b, 'b>,
 ) -> JsResult<()> {
-    let function = create_builtin_function(
+    let _function = create_builtin_function(
         agent,
         Behaviour::Regular(behaviour),
         BuiltinFunctionArgs::new(length, name, realm),
@@ -121,17 +118,17 @@ pub fn define_builtin_function<'a, 'b>(
 }
 
 pub fn define_builtin_property(
-    object: Object,
-    name: &'static str,
-    descriptor: PropertyDescriptor,
+    _object: Object,
+    _name: &'static str,
+    _descriptor: PropertyDescriptor,
 ) -> JsResult<()> {
     Ok(())
 }
 
 pub fn todo_builtin(agent: &mut Agent, _: Value, _: ArgumentsList) -> JsResult<Value> {
     agent.throw_exception(
-        crate::execution::agent::ExceptionType::SyntaxError,
+        crate::ecmascript::execution::agent::ExceptionType::SyntaxError,
         "TODO: Builtin not implemented.",
     );
-    Err(())
+    Err(Default::default())
 }

nova_vm/src/builtins/ecmascript_function.rs → nova_vm/src/ecmascript/builtins/ecmascript_function.rs

@@ -1,11 +1,8 @@
-use std::{cell::RefCell, rc::Rc};
-
 use oxc_ast::ast::{FormalParameters, FunctionBody};
 
-use crate::{
-    execution::{
-        Agent, EnvironmentIndex, JsResult, PrivateEnvironmentIndex, RealmIdentifier, ScriptOrModule,
-    },
+use crate::ecmascript::{
+    execution::{Agent, EnvironmentIndex, JsResult, PrivateEnvironmentIndex, RealmIdentifier},
+    scripts_and_modules::ScriptOrModule,
     types::{Number, Object, PropertyDescriptor, PropertyKey, Value},
 };
 

nova_vm/src/builtins/number.rs → nova_vm/src/ecmascript/builtins/number.rs

@@ -3,9 +3,11 @@ use super::{
     create_builtin_function, todo_builtin, ArgumentsList, Behaviour, Builtin, BuiltinFunctionArgs,
 };
 use crate::{
-    execution::{Agent, JsResult},
+    ecmascript::{
+        execution::{Agent, JsResult},
+        types::{Number, Object, PropertyDescriptor, Value},
+    },
     heap::CreateHeapData,
-    types::{Number, Object, PropertyDescriptor, Value},
     SmallInteger,
 };
 
@@ -185,7 +187,7 @@ impl NumberConstructor {
     /// https://tc39.es/ecma262/#sec-number-constructor-number-value
     fn behaviour(
         agent: &mut Agent,
-        this_value: Value,
+        _this_value: Value,
         arguments: ArgumentsList,
         new_target: Option<Object>,
     ) -> JsResult<Value> {
@@ -212,7 +214,7 @@ impl NumberConstructor {
         };
 
         // 3. If NewTarget is undefined, return n.
-        let Some(new_target) = new_target else {
+        let Some(_new_target) = new_target else {
             return Ok(n);
         };
 

nova_vm/src/builtins/ordinary.rs → nova_vm/src/ecmascript/builtins/ordinary.rs

@@ -1,4 +1,4 @@
-use crate::{
+use crate::ecmascript::{
     execution::{Agent, JsResult},
     types::{InternalMethods, Object, PropertyDescriptor, PropertyKey, Value},
 };
@@ -46,7 +46,7 @@ fn set_prototype_of(
     prototype: Option<Object>,
 ) -> JsResult<bool> {
     // 1. Return OrdinarySetPrototypeOf(O, V).
-    return ordinary_set_prototype_of(agent, object, prototype);
+    ordinary_set_prototype_of(agent, object, prototype)
 }
 
 /// 10.1.2.1 OrdinarySetPrototypeOf ( O, V )
@@ -474,7 +474,6 @@ fn validate_and_apply_property_descriptor(
                     set: descriptor.set.or(current.set),
                     enumerable: descriptor.enumerable.or(current.enumerable),
                     configurable: descriptor.configurable.or(current.configurable),
-                    ..Default::default()
                 },
             );
         }
@@ -506,7 +505,7 @@ pub fn ordinary_has_property(
     let has_own = (object.internal_methods(agent).get_own_property)(agent, object, property_key)?;
 
     // 2. If hasOwn is not undefined, return true.
-    if let Some(_) = has_own {
+    if has_own.is_some() {
         return Ok(true);
     }
 
@@ -569,7 +568,7 @@ pub fn ordinary_get(
 
     // 5. Let getter be desc.[[Get]].
     // 6. If getter is undefined, return undefined.
-    let Some(getter) = descriptor.get else {
+    let Some(_getter) = descriptor.get else {
         return Ok(Value::Undefined);
     };
 
@@ -703,7 +702,7 @@ pub fn ordinary_set_with_own_descriptor(
 
     // 4. Let setter be ownDesc.[[Set]].
     // 5. If setter is undefined, return false.
-    let Some(setter) = own_descriptor.set else {
+    let Some(_setter) = own_descriptor.set else {
         return Ok(false);
     };
 
@@ -757,9 +756,12 @@ fn own_property_keys(agent: &mut Agent, object: Object) -> JsResult<Vec<Property
 
 /// 10.1.11.1 OrdinaryOwnPropertyKeys ( O )
 /// https://tc39.es/ecma262/#sec-ordinaryownpropertykeys
-pub fn ordinary_own_property_keys(agent: &mut Agent, object: Object) -> JsResult<Vec<PropertyKey>> {
+pub fn ordinary_own_property_keys(
+    _agent: &mut Agent,
+    _object: Object,
+) -> JsResult<Vec<PropertyKey>> {
     // 1. Let keys be a new empty List.
-    let mut keys = Vec::new();
+    let keys = Vec::new();
 
     // 2. For each own property key P of O such that P is an array index, in ascending numeric
     //    index order, do

nova_vm/src/execution.rs → nova_vm/src/ecmascript/execution.rs

@@ -10,5 +10,5 @@ pub use environments::{
     FunctionEnvironment, FunctionEnvironmentIndex, GlobalEnvironment, GlobalEnvironmentIndex,
     ObjectEnvironment, ObjectEnvironmentIndex, PrivateEnvironment, PrivateEnvironmentIndex,
 };
-pub use execution_context::{ECMAScriptCode, ExecutionContext, ScriptOrModule};
+pub use execution_context::{ECMAScriptCode, ExecutionContext};
 pub use realm::{Intrinsics, Realm, RealmIdentifier};

nova_vm/src/execution/agent.rs → nova_vm/src/ecmascript/execution/agent.rs

@@ -1,6 +1,6 @@
 use super::{ExecutionContext, Realm, RealmIdentifier};
 use crate::{
-    types::{Object, Symbol, Value},
+    ecmascript::types::{Object, Symbol, Value},
     Heap,
 };
 use std::collections::HashMap;
@@ -12,7 +12,10 @@ pub struct Options {
     pub print_bytecode: bool,
 }
 
-pub type JsResult<T> = std::result::Result<T, ()>;
+pub type JsResult<T> = std::result::Result<T, JsError>;
+
+#[derive(Debug, Default, Clone, Copy)]
+pub struct JsError {}
 
 // #[derive(Debug)]
 // pub struct PreAllocated;
@@ -60,7 +63,7 @@ impl<'ctx, 'host> Agent<'ctx, 'host> {
 
     /// 5.2.3.2 Throw an Exception
     /// https://tc39.es/ecma262/#sec-throw-an-exception
-    pub fn throw_exception(&mut self, kind: ExceptionType, message: &'static str) -> () {
+    pub fn throw_exception(&mut self, _kind: ExceptionType, _message: &'static str) -> JsError {
         todo!()
     }
 }

nova_vm/src/execution/default_host_hooks.rs → nova_vm/src/ecmascript/execution/default_host_hooks.rs

@@ -1,5 +1,5 @@
 use super::{JsResult, Realm};
-use crate::types::Function;
+use crate::ecmascript::types::Function;
 
 /// 19.2.1.2 HostEnsureCanCompileStrings ( calleeRealm )
 /// https://tc39.es/ecma262/#sec-hostensurecancompilestrings
@@ -11,5 +11,5 @@ pub fn host_ensure_can_compile_strings(_: &mut Realm) -> JsResult<()> {
 /// https://tc39.es/ecma262/#sec-hosthassourcetextavailable
 pub fn host_has_source_text_available(_: Function) -> bool {
     // The default implementation of HostHasSourceTextAvailable is to return true.
-    return true;
+    true
 }