Support to_alias_override/to_alias_fallback in Require trait (Luau)

Author: khvzak

src/luau/require.rs

@@ -66,6 +66,24 @@ pub trait Require {
     /// configuration file.
     fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError>;
 
+    /// Provides an initial alias override opportunity prior to searching for
+    /// configuration files.
+    ///
+    /// If `Ok(())` is returned, alias resolution stops here and the internal state
+    /// must point at the aliased location.
+    fn to_alias_override(&mut self, _alias: &str) -> StdResult<(), NavigateError> {
+        Err(NavigateError::NotFound)
+    }
+
+    /// Provides a final opportunity to resolve an alias if it cannot be found in
+    /// configuration files.
+    ///
+    /// If `Ok(())` is returned, alias resolution stops here and the internal state
+    /// must point at the aliased location.
+    fn to_alias_fallback(&mut self, _alias: &str) -> StdResult<(), NavigateError> {
+        Err(NavigateError::NotFound)
+    }
+
     // Navigate to parent directory
     fn to_parent(&mut self) -> StdResult<(), NavigateError>;
 
@@ -192,6 +210,30 @@ pub(super) unsafe extern "C-unwind" fn init_config(config: *mut ffi::luarequire_
         })
     }
 
+    unsafe extern "C-unwind" fn to_alias_override(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        alias_unprefixed: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let alias = CStr::from_ptr(alias_unprefixed).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_alias_override(&alias).into_nav_result()
+        })
+    }
+
+    unsafe extern "C-unwind" fn to_alias_fallback(
+        state: *mut ffi::lua_State,
+        ctx: *mut c_void,
+        alias_unprefixed: *const c_char,
+    ) -> ffi::luarequire_NavigateResult {
+        let mut this = try_borrow_mut!(state, ctx);
+        let alias = CStr::from_ptr(alias_unprefixed).to_string_lossy();
+        callback_error_ext(state, ptr::null_mut(), true, move |_, _| {
+            this.to_alias_fallback(&alias).into_nav_result()
+        })
+    }
+
     unsafe extern "C-unwind" fn to_parent(
         state: *mut ffi::lua_State,
         ctx: *mut c_void,
@@ -298,8 +340,8 @@ pub(super) unsafe extern "C-unwind" fn init_config(config: *mut ffi::luarequire_
     (*config).is_require_allowed = is_require_allowed;
     (*config).reset = reset;
     (*config).jump_to_alias = jump_to_alias;
-    (*config).to_alias_override = None;
-    (*config).to_alias_fallback = None;
+    (*config).to_alias_override = Some(to_alias_override);
+    (*config).to_alias_fallback = Some(to_alias_fallback);
     (*config).to_parent = to_parent;
     (*config).to_child = to_child;
     (*config).is_module_present = is_module_present;

tests/luau/require.rs

@@ -251,6 +251,152 @@ fn test_require_with_config_luau() {
     test_require_with_config_inner("with_config_luau");
 }
 
+#[test]
+fn test_alias_override() {
+    let lua = Lua::new();
+
+    struct OverrideRequire(FsRequirer);
+
+    impl Require for OverrideRequire {
+        fn is_require_allowed(&self, chunk_name: &str) -> bool {
+            self.0.is_require_allowed(chunk_name)
+        }
+
+        fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
+            self.0.reset(chunk_name)
+        }
+
+        fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
+            self.0.jump_to_alias(path)
+        }
+
+        fn to_alias_override(&mut self, alias: &str) -> StdResult<(), NavigateError> {
+            if alias == "testoverride" {
+                self.0.jump_to_alias("./tests/luau/require/without_config")
+            } else {
+                Err(NavigateError::NotFound)
+            }
+        }
+
+        fn to_parent(&mut self) -> StdResult<(), NavigateError> {
+            self.0.to_parent()
+        }
+
+        fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError> {
+            self.0.to_child(name)
+        }
+
+        fn has_module(&self) -> bool {
+            self.0.has_module()
+        }
+
+        fn cache_key(&self) -> String {
+            self.0.cache_key()
+        }
+
+        fn has_config(&self) -> bool {
+            self.0.has_config()
+        }
+
+        fn config(&self) -> IoResult<Vec<u8>> {
+            self.0.config()
+        }
+
+        fn loader(&self, lua: &Lua) -> Result<mlua::Function> {
+            self.0.loader(lua)
+        }
+    }
+
+    let require_fn = lua
+        .create_require_function(OverrideRequire(FsRequirer::new()))
+        .unwrap();
+    lua.globals().set("require", require_fn).unwrap();
+
+    // to_alias_override intercepts before config-file search
+    let res = run_require(&lua, "@testoverride/dependency").unwrap();
+    assert_eq!("result from dependency", get_str(&res, 1));
+
+    // Different sub-path through the same alias
+    let res = run_require(&lua, "@testoverride/module").unwrap();
+    assert_eq!("required into module", get_str(&res, 2));
+
+    // Aliases not handled by the override still fail normally
+    let res = run_require(&lua, "@unknown_alias_xyz/anything");
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("@unknown_alias_xyz is not a valid alias"));
+}
+
+#[test]
+fn test_alias_fallback() {
+    let lua = Lua::new();
+
+    struct FallbackRequire(FsRequirer);
+
+    impl Require for FallbackRequire {
+        fn is_require_allowed(&self, chunk_name: &str) -> bool {
+            self.0.is_require_allowed(chunk_name)
+        }
+
+        fn reset(&mut self, chunk_name: &str) -> StdResult<(), NavigateError> {
+            self.0.reset(chunk_name)
+        }
+
+        fn jump_to_alias(&mut self, path: &str) -> StdResult<(), NavigateError> {
+            self.0.jump_to_alias(path)
+        }
+
+        fn to_alias_fallback(&mut self, alias: &str) -> StdResult<(), NavigateError> {
+            if alias == "testfallback" {
+                self.0.jump_to_alias("./tests/luau/require/without_config")
+            } else {
+                Err(NavigateError::NotFound)
+            }
+        }
+
+        fn to_parent(&mut self) -> StdResult<(), NavigateError> {
+            self.0.to_parent()
+        }
+
+        fn to_child(&mut self, name: &str) -> StdResult<(), NavigateError> {
+            self.0.to_child(name)
+        }
+
+        fn has_module(&self) -> bool {
+            self.0.has_module()
+        }
+
+        fn cache_key(&self) -> String {
+            self.0.cache_key()
+        }
+
+        fn has_config(&self) -> bool {
+            self.0.has_config()
+        }
+
+        fn config(&self) -> IoResult<Vec<u8>> {
+            self.0.config()
+        }
+
+        fn loader(&self, lua: &Lua) -> Result<mlua::Function> {
+            self.0.loader(lua)
+        }
+    }
+
+    let require_fn = lua
+        .create_require_function(FallbackRequire(FsRequirer::new()))
+        .unwrap();
+    lua.globals().set("require", require_fn).unwrap();
+
+    // to_alias_fallback catches after config-file search misses
+    let res = run_require(&lua, "@testfallback/dependency").unwrap();
+    assert_eq!("result from dependency", get_str(&res, 1));
+
+    // Aliases not handled by the fallback still fail
+    let res = run_require(&lua, "@unknown_alias_xyz/anything");
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("@unknown_alias_xyz is not a valid alias"));
+}
+
 #[cfg(all(feature = "async", not(windows)))]
 #[tokio::test]
 async fn test_async_require() -> Result<()> {