add location information to function calls

Author: makspll

crates/bevy_mod_scripting_bindings/src/function/script_function.rs

@@ -44,12 +44,36 @@ pub trait ScriptFunctionMut<'env, Marker> {
 #[reflect(opaque)]
 pub struct FunctionCallContext {
     language: Language,
+    location_context: Option<LocationContext>,
+}
+
+#[derive(Clone, Debug, Reflect)]
+/// Describes a location within a script
+pub struct LocationContext {
+    /// The line number
+    pub line: u32,
+    /// The column number
+    pub col: u32,
 }
 
 impl FunctionCallContext {
     /// Create a new FunctionCallContext with the given 1-indexing conversion preference
     pub const fn new(language: Language) -> Self {
-        Self { language }
+        Self {
+            language,
+            location_context: None,
+        }
+    }
+
+    /// Creates a new function call context with location information
+    pub const fn new_with_location(
+        language: Language,
+        location_context: Option<LocationContext>,
+    ) -> Self {
+        Self {
+            language,
+            location_context,
+        }
     }
 
     /// Tries to access the world, returning an error if the world is not available
@@ -68,6 +92,11 @@ impl FunctionCallContext {
     pub fn language(&self) -> Language {
         self.language.clone()
     }
+
+    /// Returns call location inside the script if available
+    pub fn location(&self) -> Option<&LocationContext> {
+        self.location_context.as_ref()
+    }
 }
 
 #[derive(Reflect, Clone, DebugWithTypeInfo)]

crates/languages/bevy_mod_scripting_lua/src/bindings/script_value.rs

@@ -5,7 +5,8 @@ use std::{
 
 use bevy_mod_scripting_asset::Language;
 use bevy_mod_scripting_bindings::{
-    error::InteropError, function::script_function::FunctionCallContext, script_value::ScriptValue,
+    LocationContext, error::InteropError, function::script_function::FunctionCallContext,
+    script_value::ScriptValue,
 };
 use bevy_platform::collections::HashMap;
 use mlua::{FromLua, IntoLua, Value, Variadic};
@@ -140,18 +141,32 @@ impl IntoLua for LuaScriptValue {
             ScriptValue::Reference(r) => LuaReflectReference::from(r).into_lua(lua)?,
             ScriptValue::Error(script_error) => return Err(mlua::Error::external(script_error)),
             ScriptValue::Function(function) => lua
-                .create_function(move |_lua, args: Variadic<LuaScriptValue>| {
+                .create_function(move |lua, args: Variadic<LuaScriptValue>| {
+                    let loc = lua.inspect_stack(0).map(|debug| LocationContext {
+                        line: debug.curr_line() as u32,
+                        col: 0,
+                    });
                     let out = function
-                        .call(args.into_iter().map(Into::into), LUA_CALLER_CONTEXT)
+                        .call(
+                            args.into_iter().map(Into::into),
+                            FunctionCallContext::new_with_location(Language::Lua, loc),
+                        )
                         .map_err(IntoMluaError::to_lua_error)?;
 
                     Ok(LuaScriptValue::from(out))
                 })?
                 .into_lua(lua)?,
             ScriptValue::FunctionMut(function) => lua
-                .create_function(move |_lua, args: Variadic<LuaScriptValue>| {
+                .create_function(move |lua, args: Variadic<LuaScriptValue>| {
+                    let loc = lua.inspect_stack(0).map(|debug| LocationContext {
+                        line: debug.curr_line() as u32,
+                        col: 0,
+                    });
                     let out = function
-                        .call(args.into_iter().map(Into::into), LUA_CALLER_CONTEXT)
+                        .call(
+                            args.into_iter().map(Into::into),
+                            FunctionCallContext::new_with_location(Language::Lua, loc),
+                        )
                         .map_err(IntoMluaError::to_lua_error)?;
 
                     Ok(LuaScriptValue::from(out))