Fix require

Author: CppCXY

crates/luars/src/lua_vm/mod.rs

@@ -2420,8 +2420,7 @@ impl LuaVM {
             }
             Err(LuaError::Yield) => {
                 // Yield is not an error - propagate it
-                let values = self.take_yield_values();
-                Err(self.do_yield(values))
+                Err(LuaError::Yield)
             }
             Err(_) => {
                 // Real error: clean up frames and return false with error message

crates/luars/src/stdlib/basic.rs

@@ -641,8 +641,8 @@ fn lua_version(vm: &mut LuaVM) -> LuaResult<MultiValue> {
 
 /// require(modname) - Load a module  
 fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
-    let modname_str = require_arg(vm, 1, "require")?;
-    if !modname_str.is_string() {
+    let modname_value = require_arg(vm, 1, "require")?;
+    if !modname_value.is_string() {
         return Err(vm.error("module name must be a string".to_string()));
     }
 
@@ -660,7 +660,7 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
             if let Some(loaded_table) = package_ref.raw_get(&loaded_key) {
                 if let Some(loaded_id) = loaded_table.as_table_id() {
                     if let Some(loaded_ref) = vm.object_pool.get_table(loaded_id) {
-                        loaded_ref.raw_get(&modname_str)
+                        loaded_ref.raw_get(&modname_value)
                     } else {
                         None
                     }
@@ -721,7 +721,7 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
     // Try each searcher (1-based indexing)
     for searcher in searchers_values {
         // Call searcher with module name
-        let (success, results) = vm.protected_call(searcher, vec![modname_str.clone()])?;
+        let (success, results) = vm.protected_call(searcher, vec![modname_value.clone()])?;
 
         if !success {
             let error_msg = results
@@ -745,15 +745,16 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
             if first_result.is_function() || first_result.is_cfunction() {
                 // Call the loader
                 let loader_args = if results.len() > 1 {
-                    vec![modname_str.clone(), results[1].clone()]
+                    vec![modname_value.clone(), results[1].clone()]
                 } else {
-                    vec![modname_str.clone()]
+                    vec![modname_value.clone()]
                 };
 
                 let (load_success, load_results) =
                     vm.protected_call(first_result.clone(), loader_args)?;
 
                 if !load_success {
+                    let module_str = vm.value_to_string(&modname_value)?;
                     let error_msg = load_results
                         .first()
                         .and_then(|v| {
@@ -766,7 +767,7 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
                         .unwrap_or_else(|| "unknown error".to_string());
                     return Err(vm.error(format!(
                         "error loading module '{}': {}",
-                        modname_str, error_msg
+                        module_str, error_msg
                     )));
                 }
 
@@ -784,7 +785,7 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
                         if let Some(loaded_table) = package_ref.raw_get(&loaded_key) {
                             if let Some(loaded_id) = loaded_table.as_table_id() {
                                 if let Some(loaded_ref) = vm.object_pool.get_table_mut(loaded_id) {
-                                    loaded_ref.raw_set(modname_str, module_value.clone());
+                                    loaded_ref.raw_set(modname_value, module_value.clone());
                                 }
                             }
                         }
@@ -800,14 +801,15 @@ fn lua_require(vm: &mut LuaVM) -> LuaResult<MultiValue> {
             }
         }
     }
+    let module_str = vm.value_to_string(&modname_value)?;
 
     // All searchers failed
     if error_messages.is_empty() {
-        Err(vm.error(format!("module '{}' not found", modname_str)))
+        Err(vm.error(format!("module '{}' not found", module_str)))
     } else {
         Err(vm.error(format!(
             "module '{}' not found:{}",
-            modname_str,
+            module_str,
             error_messages.join("")
         )))
     }

crates/luars/src/stdlib/package.rs

@@ -185,8 +185,11 @@ fn searcher_lua(vm: &mut LuaVM) -> LuaResult<MultiValue> {
 }
 
 // Loader function for Lua files (called by searcher_lua)
+// Called as: loader(modname, filepath)
 fn lua_file_loader(vm: &mut LuaVM) -> LuaResult<MultiValue> {
-    let filepath_val = require_arg(vm, 1, "Lua file loader")?;
+    // First arg is modname, second arg is filepath (passed by searcher)
+    let _modname_val = require_arg(vm, 1, "Lua file loader")?;
+    let filepath_val = require_arg(vm, 2, "Lua file loader")?;
 
     let Some(filepath_id) = filepath_val.as_string_id() else {
         return Err(vm.error("file path must be a string".to_string()));
@@ -198,21 +201,27 @@ fn lua_file_loader(vm: &mut LuaVM) -> LuaResult<MultiValue> {
         s.as_str().to_string()
     };
 
+    if !std::fs::metadata(&filepath_str).is_ok() {
+        return Ok(MultiValue::empty())
+    }
+
     // Read the file
     let source = match std::fs::read_to_string(&filepath_str) {
         Ok(s) => s,
-        Err(_) => {
-            return Ok(MultiValue::single(LuaValue::nil()));
+        Err(e) => {
+            return Err(vm.error(format!("cannot open file '{}': {}", filepath_str, e)));
         }
     };
 
     // Compile it using VM's string pool with chunk name
     let chunkname = format!("@{}", filepath_str);
     let chunk = vm.compile_with_name(&source, &chunkname)?;
-    // Create a function from the chunk
-    let func = vm.create_function(Rc::new(chunk), vec![]);
+    
+    // Create a function from the chunk with _ENV upvalue
+    let env_upvalue_id = vm.object_pool.create_upvalue_closed(vm.global_value);
+    let func = vm.create_function(Rc::new(chunk), vec![env_upvalue_id]);
 
-    // Call the function
+    // Call the function to execute the module
     let (success, results) = vm.protected_call(func, vec![])?;
 
     if !success {
@@ -228,7 +237,8 @@ fn lua_file_loader(vm: &mut LuaVM) -> LuaResult<MultiValue> {
         )));
     }
 
-    // Get the result value
+    // Get the result value - if the module returns a value, use it
+    // Otherwise return true (standard Lua behavior)
     let module_value = if results.is_empty() || results[0].is_nil() {
         LuaValue::boolean(true)
     } else {