Refactor engine with feature-gated OS and STD modules

- Configure 'os' and 'std' Cargo features for optional standard library support.
- Move 'js_std.rs', 'sprintf.rs', and 'tmpfile.rs' into 'src/js_std/' module structure.
- Apply conditional compilation guards across 'core', 'eval', and 'lib' modules.
- Update 'eval.rs' to dispatch 'os.*' and 'std.*' calls only when features are enabled.
- Add 'run-js' Cargo alias for convenient example execution with features.
- Enforce feature requirements for the 'js' example in Cargo.toml.

Author: ssrlive

.cargo/config.toml

@@ -0,0 +1,2 @@
+[alias]
+run-js = "run --example js --features=os,std --"

Cargo.toml

@@ -12,6 +12,11 @@ readme = "README.md"
 keywords = ["javascript", "engine", "interpreter", "runtime"]
 categories = ["development-tools", "parsing"]
 
+[features]
+# default = ["os", "std"]
+os = []
+std = []
+
 [dependencies]
 chrono = { version = "0.4.42", features = ["serde"] }
 gc-arena = { git = "https://github.com/kyren/gc-arena.git", rev = "40c2710" }
@@ -39,6 +44,7 @@ rustyline = "17.0.2"
 [[example]]
 name = "js"
 path = "examples/js.rs"
+required-features = ["os", "std"]
 
 [[bench]]
 name = "promise_benchmarks"

src/core/eval.rs

@@ -5,7 +5,6 @@ use crate::js_array::handle_array_static_method;
 use crate::js_bigint::bigint_constructor;
 use crate::js_date::{handle_date_method, handle_date_static_method};
 use crate::js_number::{handle_number_instance_method, handle_number_prototype_method, handle_number_static_method, number_constructor};
-use crate::js_os::handle_os_method;
 use crate::js_string::{string_from_char_code, string_from_code_point, string_raw};
 use crate::{
     JSError, JSErrorKind, PropertyKey, Value,
@@ -678,6 +677,58 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                 evaluate_expr(mc, env, else_expr)
             }
         }
+        Expr::Object(properties) => {
+            let obj = crate::core::new_js_object_data(mc);
+            if let Some(obj_val) = env_get(env, "Object") {
+                if let Value::Object(obj_ctor) = &*obj_val.borrow() {
+                    if let Some(proto_val) = obj_get_key_value(obj_ctor, &"prototype".into())? {
+                        if let Value::Object(proto) = &*proto_val.borrow() {
+                            obj.borrow_mut(mc).prototype = Some(*proto);
+                        }
+                    }
+                }
+            }
+
+            for (key_expr, val_expr, is_computed) in properties {
+                let key_val = evaluate_expr(mc, env, key_expr)?;
+                let val = evaluate_expr(mc, env, val_expr)?;
+
+                let key_str = match key_val {
+                    Value::String(s) => utf16_to_utf8(&s),
+                    Value::Number(n) => n.to_string(),
+                    Value::Boolean(b) => b.to_string(),
+                    Value::BigInt(b) => b.to_string(),
+                    Value::Undefined => "undefined".to_string(),
+                    Value::Null => "null".to_string(),
+                    _ => "object".to_string(),
+                };
+                obj_set_key_value(mc, &obj, &PropertyKey::from(key_str), val)?;
+            }
+            Ok(Value::Object(obj))
+        }
+        Expr::Array(elements) => {
+            let arr_obj = crate::core::new_js_object_data(mc);
+            if let Some(arr_val) = env_get(env, "Array") {
+                if let Value::Object(arr_ctor) = &*arr_val.borrow() {
+                    if let Some(proto_val) = obj_get_key_value(arr_ctor, &"prototype".into())? {
+                        if let Value::Object(proto) = &*proto_val.borrow() {
+                            arr_obj.borrow_mut(mc).prototype = Some(*proto);
+                        }
+                    }
+                }
+            }
+
+            let mut len = 0;
+            for (i, elem_opt) in elements.iter().enumerate() {
+                if let Some(elem) = elem_opt {
+                    let val = evaluate_expr(mc, env, elem)?;
+                    obj_set_key_value(mc, &arr_obj, &i.to_string().into(), val)?;
+                }
+                len = i + 1;
+            }
+            obj_set_key_value(mc, &arr_obj, &"length".into(), Value::Number(len as f64))?;
+            Ok(Value::Object(arr_obj))
+        }
         Expr::Function(name, params, body) => {
             let mut body_clone = body.clone();
             Ok(evaluate_function_expression(mc, env, name.clone(), params, &mut body_clone)?)
@@ -729,12 +780,50 @@ pub fn evaluate_expr<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                         }
                     } else if let Some(method_name) = name.strip_prefix("console.") {
                         crate::js_console::handle_console_method(mc, method_name, &eval_args, env)
-                    } else if let Some(method) = name.strip_prefix("os.path.") {
-                        let this_val = this_val.clone().unwrap_or(Value::Object(*env));
-                        Ok(handle_os_method(mc, this_val, method, &eval_args, env).map_err(EvalError::Js)?)
                     } else if let Some(method) = name.strip_prefix("os.") {
-                        let this_val = this_val.clone().unwrap_or(Value::Object(*env));
-                        Ok(handle_os_method(mc, this_val, method, &eval_args, env).map_err(EvalError::Js)?)
+                        #[cfg(feature = "os")]
+                        {
+                            let this_val = this_val.clone().unwrap_or(Value::Object(*env));
+                            Ok(crate::js_os::handle_os_method(mc, this_val, method, &eval_args, env).map_err(EvalError::Js)?)
+                        }
+                        #[cfg(not(feature = "os"))]
+                        {
+                            Err(EvalError::Js(raise_eval_error!(
+                                "os module not enabled. Recompile with --features os"
+                            )))
+                        }
+                    } else if let Some(method) = name.strip_prefix("std.") {
+                        #[cfg(feature = "std")]
+                        {
+                            match method {
+                                "sprintf" => Ok(crate::js_std::sprintf::handle_sprintf_call(&eval_args).map_err(EvalError::Js)?),
+                                "tmpfile" => Ok(crate::js_std::tmpfile::create_tmpfile(mc).map_err(EvalError::Js)?),
+                                _ => Err(EvalError::Js(raise_eval_error!(format!("std method '{}' not implemented", method)))),
+                            }
+                        }
+                        #[cfg(not(feature = "std"))]
+                        {
+                            Err(EvalError::Js(raise_eval_error!(
+                                "std module not enabled. Recompile with --features std"
+                            )))
+                        }
+                    } else if let Some(method) = name.strip_prefix("tmp.") {
+                        #[cfg(feature = "std")]
+                        {
+                            if let Some(Value::Object(this_obj)) = this_val {
+                                Ok(crate::js_std::tmpfile::handle_file_method(&this_obj, method, &eval_args).map_err(EvalError::Js)?)
+                            } else {
+                                Err(EvalError::Js(raise_eval_error!(
+                                    "TypeError: tmp method called on incompatible receiver"
+                                )))
+                            }
+                        }
+                        #[cfg(not(feature = "std"))]
+                        {
+                            Err(EvalError::Js(raise_eval_error!(
+                                "std module (tmpfile) not enabled. Recompile with --features std"
+                            )))
+                        }
                     } else if let Some(method) = name.strip_prefix("BigInt.prototype.") {
                         let this_v = this_val.clone().unwrap_or(Value::Undefined);
                         Ok(crate::js_bigint::handle_bigint_object_method(this_v, method, &eval_args).map_err(EvalError::Js)?)

src/core.rs src/core/mod.rssrc/core.rs renamed to src/core/mod.rs

@@ -5,7 +5,6 @@ use crate::js_console::initialize_console_object;
 use crate::js_date::initialize_date;
 use crate::js_math::initialize_math;
 use crate::js_number::initialize_number_module;
-use crate::js_os::initialize_os_module;
 use crate::js_regexp::initialize_regexp;
 use crate::js_string::initialize_string;
 use crate::raise_eval_error;
@@ -75,14 +74,19 @@ pub fn initialize_global_constructors<'gc>(mc: &MutationContext<'gc>, env: &JSOb
     initialize_regexp(mc, env)?;
     // Initialize Date constructor and prototype
     initialize_date(mc, env)?;
-    initialize_os_module(mc, env)?;
     initialize_bigint(mc, env)?;
 
     env_set(mc, env, "undefined", Value::Undefined)?;
     env_set(mc, env, "NaN", Value::Number(f64::NAN))?;
     env_set(mc, env, "Infinity", Value::Number(f64::INFINITY))?;
     env_set(mc, env, "eval", Value::Function("eval".to_string()))?;
 
+    #[cfg(feature = "os")]
+    crate::js_os::initialize_os_module(mc, env)?;
+
+    #[cfg(feature = "std")]
+    crate::js_std::initialize_std_module(mc, env)?;
+
     Ok(())
 }
 

src/core/parser.rs

@@ -1651,9 +1651,9 @@ fn parse_primary(tokens: &[TokenData], index: &mut usize, allow_call: bool) -> R
 
                     // Parse key
                     let mut is_shorthand_candidate = false;
-                    let key_expr = if let Some(Token::Identifier(name)) = tokens.first().map(|t| t.token.clone()) {
+                    let key_expr = if let Some(Token::Identifier(name)) = tokens.get(*index).map(|t| t.token.clone()) {
                         // Check for concise method: Identifier + (
-                        if !is_getter && !is_setter && tokens.len() >= 2 && matches!(tokens[1].token, Token::LParen) {
+                        if !is_getter && !is_setter && tokens.len() > *index + 1 && matches!(tokens[*index + 1].token, Token::LParen) {
                             // Concise method
                             *index += 1; // consume name
                             *index += 1; // consume (
@@ -1693,16 +1693,16 @@ fn parse_primary(tokens: &[TokenData], index: &mut usize, allow_call: bool) -> R
                         is_shorthand_candidate = true;
                         *index += 1;
                         Expr::StringLit(crate::unicode::utf8_to_utf16(&name))
-                    } else if let Some(Token::Number(n)) = tokens.first().map(|t| t.token.clone()) {
+                    } else if let Some(Token::Number(n)) = tokens.get(*index).map(|t| t.token.clone()) {
                         // Numeric property keys are allowed in object literals (they become strings)
                         *index += 1;
                         // Format as integer if whole number, otherwise use default representation
                         let s = if n.fract() == 0.0 { format!("{}", n as i64) } else { n.to_string() };
                         Expr::StringLit(crate::unicode::utf8_to_utf16(&s))
-                    } else if let Some(Token::StringLit(s)) = tokens.first().map(|t| t.token.clone()) {
+                    } else if let Some(Token::StringLit(s)) = tokens.get(*index).map(|t| t.token.clone()) {
                         *index += 1;
                         Expr::StringLit(s)
-                    } else if let Some(Token::Default) = tokens.first().map(|t| t.token.clone()) {
+                    } else if let Some(Token::Default) = tokens.get(*index).map(|t| t.token.clone()) {
                         // allow the reserved word `default` as an object property key
                         *index += 1;
                         Expr::StringLit(crate::unicode::utf8_to_utf16("default"))

src/js_function.rs

@@ -93,7 +93,6 @@ pub fn handle_global_function<'gc>(
     // Handle functions that expect unevaluated expressions
     match func_name {
         "import" => return dynamic_import_function(mc, args, env),
-        "std.sprintf" => return crate::sprintf::handle_sprintf_call(mc, env, args),
         "Function" => return function_constructor(mc, args, env),
         "new" => return evaluate_new_expression(mc, args, env),
         "eval" => return evalute_eval_function(mc, args, env),

src/js_module.rs

@@ -37,11 +37,18 @@ pub fn load_module<'gc>(mc: &MutationContext<'gc>, module_name: &str, base_path:
         let log_func = Value::Function("console.log".to_string());
         obj_set_key_value(mc, &module_exports, &"log".into(), log_func)?;
     } else if module_name == "std" {
-        let std_obj = crate::js_std::make_std_object(mc)?;
-        return Ok(Value::Object(std_obj));
+        #[cfg(feature = "std")]
+        {
+            let std_obj = crate::js_std::make_std_object(mc)?;
+            return Ok(Value::Object(std_obj));
+        }
+        #[cfg(not(feature = "std"))]
+        return Err(raise_eval_error!("Module 'std' is not built-in (feature disabled)."));
     } else if module_name == "os" {
-        let os_obj = crate::js_os::make_os_object(mc)?;
-        return Ok(Value::Object(os_obj));
+        // Removed hardcoded os module. os functionality should be injected.
+        return Err(raise_eval_error!(
+            "Module 'os' is not built-in. Please provide it via host environment."
+        ));
     } else {
         // Try to load as a file
         match load_module_from_file(mc, module_name, base_path) {

src/js_os.rs

@@ -1,3 +1,5 @@
+#![cfg(feature = "os")]
+
 use crate::core::MutationContext;
 use std::collections::HashMap;
 use std::fs::File;
@@ -325,7 +327,7 @@ pub(crate) fn handle_os_method<'gc>(
     // If this object looks like the `os.path` module
     if get_own_property(&object, &"join".into()).is_some() {
         match method {
-            "join" => {
+            "join" | "path.join" => {
                 let mut result = String::new();
                 for (i, val) in args.iter().enumerate() {
                     let part = match val {

src/js_std.rs src/js_std/mod.rssrc/js_std.rs renamed to src/js_std/mod.rs

@@ -1,3 +1,9 @@
+#![cfg(feature = "std")]
+
+pub(crate) mod sprintf;
+pub(crate) mod tmpfile;
+
+use crate::core::MutationContext;
 use crate::core::{JSObjectDataPtr, Value, new_js_object_data, obj_set_key_value};
 use crate::error::JSError;
 
@@ -7,6 +13,13 @@ fn utf8_to_utf16_local(s: &str) -> Vec<u16> {
     s.encode_utf16().collect()
 }
 
+pub fn initialize_std_module<'gc>(mc: &MutationContext<'gc>, global_obj: &JSObjectDataPtr<'gc>) -> Result<(), JSError> {
+    let std_obj = make_std_object(mc)?;
+    // Optionally expose it globally, or just rely on module system import
+    obj_set_key_value(mc, global_obj, &"std".into(), Value::Object(std_obj))?;
+    Ok(())
+}
+
 pub fn make_std_object<'gc>(mc: &MutationContext<'gc>) -> Result<JSObjectDataPtr<'gc>, JSError> {
     let obj = new_js_object_data(mc);
     obj_set_key_value(mc, &obj, &"sprintf".into(), Value::Function("std.sprintf".to_string()))?;

src/sprintf.rs src/js_std/sprintf.rssrc/sprintf.rs renamed to src/js_std/sprintf.rs

@@ -1,30 +1,27 @@
-use crate::core::JSObjectDataPtr;
-use crate::core::{Collect, Gc, GcCell, GcPtr, MutationContext, Trace};
-use crate::core::{Expr, Value, evaluate_expr};
+#![cfg(feature = "std")]
+
+use crate::core::Value;
 use crate::error::JSError;
 use crate::unicode::{utf8_to_utf16, utf16_to_utf8};
 
-pub(crate) fn handle_sprintf_call<'gc>(
-    mc: &MutationContext<'gc>,
-    env: &JSObjectDataPtr<'gc>,
-    args: &[Expr],
-) -> Result<Value<'gc>, JSError> {
+pub(crate) fn handle_sprintf_call<'gc>(args: &[Value<'gc>]) -> Result<Value<'gc>, JSError> {
     log::trace!("handle_sprintf_call called with {} args", args.len());
     if args.is_empty() {
         return Ok(Value::String(utf8_to_utf16("")));
     }
-    let format_val = evaluate_expr(mc, env, &args[0])?;
+    // args[0] is format string
+    let format_val = &args[0];
     let format_str = match format_val {
         Value::String(s) => utf16_to_utf8(&s),
         _ => {
             return Err(raise_eval_error!("sprintf format must be a string"));
         }
     };
-    let result = sprintf_impl(mc, env, &format_str, &args[1..])?;
+    let result = sprintf_impl(&format_str, &args[1..])?;
     Ok(Value::String(utf8_to_utf16(&result)))
 }
 
-pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>, format: &str, args: &[Expr]) -> Result<String, JSError> {
+pub fn sprintf_impl<'gc>(format: &str, args: &[Value<'gc>]) -> Result<String, JSError> {
     let mut result = String::new();
     let mut arg_index = 0;
     let mut chars = format.chars().peekable();
@@ -60,9 +57,9 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                 if ch == '*' {
                     chars.next();
                     if arg_index < args.len() {
-                        let width_val = evaluate_expr(mc, env, &args[arg_index])?;
+                        let width_val = &args[arg_index];
                         if let Value::Number(n) = width_val {
-                            width = Some(n as usize);
+                            width = Some(*n as usize);
                         }
                         arg_index += 1;
                     }
@@ -89,9 +86,9 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     if ch == '*' {
                         chars.next();
                         if arg_index < args.len() {
-                            let prec_val = evaluate_expr(mc, env, &args[arg_index])?;
+                            let prec_val = &args[arg_index];
                             if let Value::Number(n) = prec_val {
-                                precision = Some(n as usize);
+                                precision = Some(*n as usize);
                             }
                             arg_index += 1;
                         }
@@ -127,15 +124,15 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                 }
 
                 // Get the argument value
-                let arg_val = evaluate_expr(mc, env, &args[arg_index])?;
+                let arg_val = &args[arg_index];
 
                 match specifier {
                     'd' | 'i' => {
                         // Integer
                         let val = match arg_val {
-                            Value::Number(n) => n as i64,
+                            Value::Number(n) => *n as i64,
                             Value::Boolean(b) => {
-                                if b {
+                                if *b {
                                     1
                                 } else {
                                     0
@@ -157,7 +154,7 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     'x' | 'X' => {
                         // Hexadecimal
                         let val = match arg_val {
-                            Value::Number(n) => n as i64,
+                            Value::Number(n) => *n as i64,
                             _ => 0,
                         };
                         let formatted = if length_modifier == "l" {
@@ -174,7 +171,7 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     'f' | 'F' | 'e' | 'E' | 'g' | 'G' => {
                         // Float
                         let val = match arg_val {
-                            Value::Number(n) => n,
+                            Value::Number(n) => *n,
                             _ => 0.0,
                         };
                         let formatted = if let Some(w) = width {
@@ -208,7 +205,7 @@ pub fn sprintf_impl<'gc>(mc: &MutationContext<'gc>, env: &JSObjectDataPtr<'gc>,
                     'c' => {
                         // Character
                         let val = match arg_val {
-                            Value::Number(n) => n as u8 as char,
+                            Value::Number(n) => *n as u8 as char,
                             _ => '?',
                         };
                         result.push(val);