More Luau require tests

Author: khvzak

src/luau/require.rs

@@ -144,16 +144,18 @@ impl TextRequirer {
     fn find_module_path(path: &Path) -> StdResult<PathBuf, NavigateError> {
         let mut found_path = None;
 
-        let current_ext = (path.extension().and_then(|s| s.to_str()))
-            .map(|s| format!("{s}."))
-            .unwrap_or_default();
-        for ext in ["luau", "lua"] {
-            let candidate = path.with_extension(format!("{current_ext}{ext}"));
-            if candidate.is_file() {
-                if found_path.is_some() {
-                    return Err(NavigateError::Ambiguous);
+        if path.components().last() != Some(Component::Normal("init".as_ref())) {
+            let current_ext = (path.extension().and_then(|s| s.to_str()))
+                .map(|s| format!("{s}."))
+                .unwrap_or_default();
+            for ext in ["luau", "lua"] {
+                let candidate = path.with_extension(format!("{current_ext}{ext}"));
+                if candidate.is_file() {
+                    if found_path.is_some() {
+                        return Err(NavigateError::Ambiguous);
+                    }
+                    found_path = Some(candidate);
                 }
-                found_path = Some(candidate);
             }
         }
         if path.is_dir() {

tests/luau/require.rs

@@ -1,9 +1,13 @@
-use mlua::{IntoLua, Lua, Result, Value};
+use mlua::{IntoLua, Lua, MultiValue, Result, Value};
 
 fn run_require(lua: &Lua, path: impl IntoLua) -> Result<Value> {
     lua.load(r#"return require(...)"#).call(path)
 }
 
+fn run_require_pcall(lua: &Lua, path: impl IntoLua) -> Result<MultiValue> {
+    lua.load(r#"return pcall(require, ...)"#).call(path)
+}
+
 #[track_caller]
 fn get_str(value: &Value, key: impl IntoLua) -> String {
     value.as_table().unwrap().get::<String>(key).unwrap()
@@ -32,6 +36,13 @@ fn test_require_errors() {
     assert!(res.is_err());
     assert!((res.unwrap_err().to_string())
         .contains("bad argument #1 to 'require' (string expected, got boolean)"));
+
+    // Require from loadstring
+    let res = lua
+        .load(r#"return loadstring("require('./a/relative/path')")()"#)
+        .eval::<Value>();
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("require is not supported in this context"));
 }
 
 #[test]
@@ -42,6 +53,11 @@ fn test_require_without_config() {
     let res = run_require(&lua, "./require/without_config/dependency").unwrap();
     assert_eq!("result from dependency", get_str(&res, 1));
 
+    // RequireSimpleRelativePathWithinPcall
+    let res = run_require_pcall(&lua, "./require/without_config/dependency").unwrap();
+    assert!(res[0].as_boolean().unwrap());
+    assert_eq!("result from dependency", get_str(&res[1], 1));
+
     // RequireRelativeToRequiringFile
     let res = run_require(&lua, "./require/without_config/module").unwrap();
     assert_eq!("result from dependency", get_str(&res, 1));
@@ -59,10 +75,24 @@ fn test_require_without_config() {
     let res = run_require(&lua, "./require/without_config/lua").unwrap();
     assert_eq!("result from init.lua", get_str(&res, 1));
 
-    // RequireSubmoduleUsingSelf
+    // RequireSubmoduleUsingSelfIndirectly
     let res = run_require(&lua, "./require/without_config/nested_module_requirer").unwrap();
     assert_eq!("result from submodule", get_str(&res, 1));
 
+    // RequireSubmoduleUsingSelfDirectly
+    let res = run_require(&lua, "./require/without_config/nested").unwrap();
+    assert_eq!("result from submodule", get_str(&res, 1));
+
+    // CannotRequireInitLuauDirectly
+    let res = run_require(&lua, "./require/without_config/nested/init");
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("could not resolve child component \"init\""));
+
+    // RequireNestedInits
+    let res = run_require(&lua, "./require/without_config/nested_inits_requirer").unwrap();
+    assert_eq!("result from nested_inits/init", get_str(&res, 1));
+    assert_eq!("required into module", get_str(&res, 2));
+
     // RequireWithFileAmbiguity
     let res = run_require(&lua, "./require/without_config/ambiguous_file_requirer");
     assert!(res.is_err());

tests/luau/require/without_config/nested_inits/init.luau

@@ -0,0 +1,2 @@
+local result = require("@self/init")
+return result

tests/luau/require/without_config/nested_inits/init/init.luau

@@ -0,0 +1 @@
+return {"result from nested_inits/init"}

tests/luau/require/without_config/nested_inits_requirer.luau

@@ -0,0 +1,3 @@
+local result = require("./nested_inits")
+result[#result+1] = "required into module"
+return result