diff --git a/Cargo.lock b/Cargo.lock index d1afd81..9a1b727 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -437,9 +437,9 @@ dependencies = [ [[package]] name = "cc" -version = "1.1.30" +version = "1.2.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b16803a61b81d9eabb7eae2588776c4c1e584b738ede45fdbb4c972cec1e9945" +checksum = "8e3a13707ac958681c13b39b458c073d0d9bc8a22cb1b2f4c8e55eb72c13f362" dependencies = [ "jobserver", "libc", @@ -833,6 +833,12 @@ version = "1.0.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813" +[[package]] +name = "either" +version = "1.15.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719" + [[package]] name = "encode_unicode" version = "0.3.6" @@ -1539,9 +1545,9 @@ dependencies = [ [[package]] name = "luau0-src" -version = "0.10.3+luau640" +version = "0.12.3+luau663" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2f39d12b514a676c943990cfbe6200fedcb9c293c8c9219d29be512a6969be92" +checksum = "76ae337c644bbf86a8d8e9ce3ee023311833d41741baf5e51acc31b37843aba1" dependencies = [ "cc", ] @@ -1841,17 +1847,18 @@ dependencies = [ [[package]] name = "mlua" -version = "0.9.9" +version = "0.10.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d111deb18a9c9bd33e1541309f4742523bfab01d276bfa9a27519f6de9c11dc7" +checksum = "d3f763c1041eff92ffb5d7169968a327e1ed2ebfe425dac0ee5a35f29082534b" dependencies = [ "bstr", + "either", "erased-serde", "futures-util", "libloading", "mlua-sys", "num-traits", - "once_cell", + "parking_lot", "rustc-hash 2.0.0", "serde", "serde-value", @@ -1878,9 +1885,9 @@ dependencies = [ [[package]] name = "mlua-sys" -version = "0.6.3" +version = "0.6.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebe026d6bd1583a9cf9080e189030ddaea7e6f5f0deb366a8e26f8a26c4135b8" +checksum = "1901c1a635a22fe9250ffcc4fcc937c16b47c2e9e71adba8784af8bca1f69594" dependencies = [ "cc", "cfg-if 1.0.0", diff --git a/crates/lune-roblox/Cargo.toml b/crates/lune-roblox/Cargo.toml index 8fb8940..78e9688 100644 --- a/crates/lune-roblox/Cargo.toml +++ b/crates/lune-roblox/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } glam = "0.27" rand = "0.8" diff --git a/crates/lune-roblox/src/datatypes/conversion.rs b/crates/lune-roblox/src/datatypes/conversion.rs index 201ab00..84b007e 100644 --- a/crates/lune-roblox/src/datatypes/conversion.rs +++ b/crates/lune-roblox/src/datatypes/conversion.rs @@ -6,7 +6,7 @@ use crate::{datatypes::extension::DomValueExt, instance::Instance}; use super::*; -pub(crate) trait LuaToDomValue<'lua> { +pub(crate) trait LuaToDomValue { /** Converts a lua value into a weak dom value. @@ -15,16 +15,16 @@ pub(crate) trait LuaToDomValue<'lua> { */ fn lua_to_dom_value( &self, - lua: &'lua Lua, + lua: &Lua, variant_type: Option, ) -> DomConversionResult; } -pub(crate) trait DomValueToLua<'lua>: Sized { +pub(crate) trait DomValueToLua: Sized { /** Converts a weak dom value into a lua value. */ - fn dom_value_to_lua(lua: &'lua Lua, variant: &DomValue) -> DomConversionResult; + fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionResult; } /* @@ -37,8 +37,8 @@ pub(crate) trait DomValueToLua<'lua>: Sized { */ -impl<'lua> DomValueToLua<'lua> for LuaValue<'lua> { - fn dom_value_to_lua(lua: &'lua Lua, variant: &DomValue) -> DomConversionResult { +impl DomValueToLua for LuaValue { + fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionResult { use rbx_dom_weak::types as dom; match LuaAnyUserData::dom_value_to_lua(lua, variant) { @@ -76,10 +76,10 @@ impl<'lua> DomValueToLua<'lua> for LuaValue<'lua> { } } -impl<'lua> LuaToDomValue<'lua> for LuaValue<'lua> { +impl LuaToDomValue for LuaValue { fn lua_to_dom_value( &self, - lua: &'lua Lua, + lua: &Lua, variant_type: Option, ) -> DomConversionResult { use rbx_dom_weak::types as dom; @@ -102,7 +102,7 @@ impl<'lua> LuaToDomValue<'lua> for LuaValue<'lua> { Ok(DomValue::String(s.to_str()?.to_string())) } (LuaValue::String(s), DomType::BinaryString) => { - Ok(DomValue::BinaryString(s.as_ref().into())) + Ok(DomValue::BinaryString(s.as_bytes().to_vec().into())) } (LuaValue::String(s), DomType::ContentId) => { Ok(DomValue::ContentId(s.to_str()?.to_string().into())) @@ -186,9 +186,9 @@ macro_rules! userdata_to_dom { }; } -impl<'lua> DomValueToLua<'lua> for LuaAnyUserData<'lua> { +impl DomValueToLua for LuaAnyUserData { #[rustfmt::skip] - fn dom_value_to_lua(lua: &'lua Lua, variant: &DomValue) -> DomConversionResult { + fn dom_value_to_lua(lua: &Lua, variant: &DomValue) -> DomConversionResult { use super::types::*; use rbx_dom_weak::types as dom; @@ -235,13 +235,9 @@ impl<'lua> DomValueToLua<'lua> for LuaAnyUserData<'lua> { } } -impl<'lua> LuaToDomValue<'lua> for LuaAnyUserData<'lua> { +impl LuaToDomValue for LuaAnyUserData { #[rustfmt::skip] - fn lua_to_dom_value( - &self, - _: &'lua Lua, - variant_type: Option, - ) -> DomConversionResult { + fn lua_to_dom_value(&self, _: &Lua, variant_type: Option) -> DomConversionResult { use super::types::*; use rbx_dom_weak::types as dom; @@ -279,13 +275,13 @@ impl<'lua> LuaToDomValue<'lua> for LuaAnyUserData<'lua> { // NOTE: The none and default variants of these types are handled in // LuaToDomValue for the LuaValue type instead, allowing for nil/default DomType::OptionalCFrame => { - return match self.borrow::() { + match self.borrow::() { Err(_) => unreachable!("Invalid use of conversion method, should be using LuaValue"), Ok(value) => Ok(DomValue::OptionalCFrame(Some(dom::CFrame::from(*value)))), } } DomType::PhysicalProperties => { - return match self.borrow::() { + match self.borrow::() { Err(_) => unreachable!("Invalid use of conversion method, should be using LuaValue"), Ok(value) => { let props = dom::CustomPhysicalProperties::from(*value); diff --git a/crates/lune-roblox/src/datatypes/types/axes.rs b/crates/lune-roblox/src/datatypes/types/axes.rs index e9aa950..0377e67 100644 --- a/crates/lune-roblox/src/datatypes/types/axes.rs +++ b/crates/lune-roblox/src/datatypes/types/axes.rs @@ -21,11 +21,11 @@ pub struct Axes { pub(crate) z: bool, } -impl LuaExportsTable<'_> for Axes { +impl LuaExportsTable for Axes { const EXPORT_NAME: &'static str = "Axes"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let axes_new = |_, args: LuaMultiValue| { + fn create_exports_table(lua: Lua) -> LuaResult { + let axes_new = |_: &Lua, args: LuaMultiValue| { let mut x = false; let mut y = false; let mut z = false; @@ -76,7 +76,7 @@ impl LuaExportsTable<'_> for Axes { } impl LuaUserData for Axes { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("X", |_, this| Ok(this.x)); fields.add_field_method_get("Y", |_, this| Ok(this.y)); fields.add_field_method_get("Z", |_, this| Ok(this.z)); @@ -88,7 +88,7 @@ impl LuaUserData for Axes { fields.add_field_method_get("Back", |_, this| Ok(this.z)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/brick_color.rs b/crates/lune-roblox/src/datatypes/types/brick_color.rs index 297793b..fdd9a1b 100644 --- a/crates/lune-roblox/src/datatypes/types/brick_color.rs +++ b/crates/lune-roblox/src/datatypes/types/brick_color.rs @@ -24,16 +24,16 @@ pub struct BrickColor { pub(crate) rgb: (u8, u8, u8), } -impl LuaExportsTable<'_> for BrickColor { +impl LuaExportsTable for BrickColor { const EXPORT_NAME: &'static str = "BrickColor"; - fn create_exports_table(lua: &Lua) -> LuaResult { + fn create_exports_table(lua: Lua) -> LuaResult { type ArgsNumber = u16; type ArgsName = String; type ArgsRgb = (u8, u8, u8); - type ArgsColor3<'lua> = LuaUserDataRef<'lua, Color3>; + type ArgsColor3 = LuaUserDataRef; - let brick_color_new = |lua, args: LuaMultiValue| { + let brick_color_new = |lua: &Lua, args: LuaMultiValue| { if let Ok(number) = ArgsNumber::from_lua_multi(args.clone(), lua) { Ok(color_from_number(number)) } else if let Ok(name) = ArgsName::from_lua_multi(args.clone(), lua) { @@ -50,7 +50,7 @@ impl LuaExportsTable<'_> for BrickColor { } }; - let brick_color_palette = |_, index: u16| { + let brick_color_palette = |_: &Lua, index: u16| { if index == 0 { Err(LuaError::RuntimeError("Invalid index".to_string())) } else if let Some(number) = BRICK_COLOR_PALETTE.get((index - 1) as usize) { @@ -60,7 +60,7 @@ impl LuaExportsTable<'_> for BrickColor { } }; - let brick_color_random = |_, ()| { + let brick_color_random = |_: &Lua, ()| { let number = BRICK_COLOR_PALETTE.choose(&mut rand::thread_rng()); Ok(color_from_number(*number.unwrap())) }; @@ -71,7 +71,7 @@ impl LuaExportsTable<'_> for BrickColor { .with_function("random", brick_color_random)?; for (name, number) in BRICK_COLOR_CONSTRUCTORS { - let f = |_, ()| Ok(color_from_number(*number)); + let f = |_: &Lua, ()| Ok(color_from_number(*number)); builder = builder.with_function(*name, f)?; } @@ -80,7 +80,7 @@ impl LuaExportsTable<'_> for BrickColor { } impl LuaUserData for BrickColor { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Number", |_, this| Ok(this.number)); fields.add_field_method_get("Name", |_, this| Ok(this.name)); fields.add_field_method_get("R", |_, this| Ok(this.rgb.0 as f32 / 255f32)); @@ -92,7 +92,7 @@ impl LuaUserData for BrickColor { fields.add_field_method_get("Color", |_, this| Ok(Color3::from(*this))); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/cframe.rs b/crates/lune-roblox/src/datatypes/types/cframe.rs index 6c9cfa9..d8fa0ad 100644 --- a/crates/lune-roblox/src/datatypes/types/cframe.rs +++ b/crates/lune-roblox/src/datatypes/types/cframe.rs @@ -43,27 +43,28 @@ impl CFrame { } } -impl LuaExportsTable<'_> for CFrame { +impl LuaExportsTable for CFrame { const EXPORT_NAME: &'static str = "CFrame"; #[allow(clippy::too_many_lines)] - fn create_exports_table(lua: &Lua) -> LuaResult { - let cframe_angles = |_, (rx, ry, rz): (f32, f32, f32)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let cframe_angles = |_: &Lua, (rx, ry, rz): (f32, f32, f32)| { Ok(CFrame(Mat4::from_euler(EulerRot::XYZ, rx, ry, rz))) }; - let cframe_from_axis_angle = - |_, (v, r): (LuaUserDataRef, f32)| Ok(CFrame(Mat4::from_axis_angle(v.0, r))); + let cframe_from_axis_angle = |_: &Lua, (v, r): (LuaUserDataRef, f32)| { + Ok(CFrame(Mat4::from_axis_angle(v.0, r))) + }; - let cframe_from_euler_angles_xyz = |_, (rx, ry, rz): (f32, f32, f32)| { + let cframe_from_euler_angles_xyz = |_: &Lua, (rx, ry, rz): (f32, f32, f32)| { Ok(CFrame(Mat4::from_euler(EulerRot::XYZ, rx, ry, rz))) }; - let cframe_from_euler_angles_yxz = |_, (rx, ry, rz): (f32, f32, f32)| { + let cframe_from_euler_angles_yxz = |_: &Lua, (rx, ry, rz): (f32, f32, f32)| { Ok(CFrame(Mat4::from_euler(EulerRot::YXZ, ry, rx, rz))) }; - let cframe_from_matrix = |_, + let cframe_from_matrix = |_: &Lua, (pos, rx, ry, rz): ( LuaUserDataRef, LuaUserDataRef, @@ -79,11 +80,11 @@ impl LuaExportsTable<'_> for CFrame { ))) }; - let cframe_from_orientation = |_, (rx, ry, rz): (f32, f32, f32)| { + let cframe_from_orientation = |_: &Lua, (rx, ry, rz): (f32, f32, f32)| { Ok(CFrame(Mat4::from_euler(EulerRot::YXZ, ry, rx, rz))) }; - let cframe_look_at = |_, + let cframe_look_at = |_: &Lua, (from, to, up): ( LuaUserDataRef, LuaUserDataRef, @@ -97,18 +98,18 @@ impl LuaExportsTable<'_> for CFrame { }; // Dynamic args constructor - type ArgsPos<'lua> = LuaUserDataRef<'lua, Vector3>; - type ArgsLook<'lua> = ( - LuaUserDataRef<'lua, Vector3>, - LuaUserDataRef<'lua, Vector3>, - Option>, + type ArgsPos = LuaUserDataRef; + type ArgsLook = ( + LuaUserDataRef, + LuaUserDataRef, + Option>, ); type ArgsPosXYZ = (f32, f32, f32); type ArgsPosXYZQuat = (f32, f32, f32, f32, f32, f32, f32); type ArgsMatrix = (f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32, f32); - let cframe_new = |lua, args: LuaMultiValue| match args.len() { + let cframe_new = |lua: &Lua, args: LuaMultiValue| match args.len() { 0 => Ok(CFrame(Mat4::IDENTITY)), 1 => match ArgsPos::from_lua_multi(args, lua) { @@ -174,7 +175,7 @@ impl LuaExportsTable<'_> for CFrame { } impl LuaUserData for CFrame { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Position", |_, this| Ok(Vector3(this.position()))); fields.add_field_method_get("Rotation", |_, this| { Ok(CFrame(Mat4::from_cols( @@ -200,7 +201,7 @@ impl LuaUserData for CFrame { } #[allow(clippy::too_many_lines)] - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("Inverse", |_, this, ()| Ok(this.inverse())); methods.add_method( @@ -326,7 +327,7 @@ impl LuaUserData for CFrame { } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: "userdata", + to: "userdata".to_string(), message: Some(format!( "Expected CFrame or Vector3, got {}", rhs.type_name() diff --git a/crates/lune-roblox/src/datatypes/types/color3.rs b/crates/lune-roblox/src/datatypes/types/color3.rs index 8523732..0992b49 100644 --- a/crates/lune-roblox/src/datatypes/types/color3.rs +++ b/crates/lune-roblox/src/datatypes/types/color3.rs @@ -28,11 +28,11 @@ pub struct Color3 { pub(crate) b: f32, } -impl LuaExportsTable<'_> for Color3 { +impl LuaExportsTable for Color3 { const EXPORT_NAME: &'static str = "Color3"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let color3_from_rgb = |_, (r, g, b): (Option, Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let color3_from_rgb = |_: &Lua, (r, g, b): (Option, Option, Option)| { Ok(Color3 { r: (r.unwrap_or_default() as f32) / 255f32, g: (g.unwrap_or_default() as f32) / 255f32, @@ -40,7 +40,7 @@ impl LuaExportsTable<'_> for Color3 { }) }; - let color3_from_hsv = |_, (h, s, v): (f32, f32, f32)| { + let color3_from_hsv = |_: &Lua, (h, s, v): (f32, f32, f32)| { // https://axonflux.com/handy-rgb-to-hsl-and-rgb-to-hsv-color-model-c let i = (h * 6.0).floor(); let f = h * 6.0 - i; @@ -61,7 +61,7 @@ impl LuaExportsTable<'_> for Color3 { Ok(Color3 { r, g, b }) }; - let color3_from_hex = |_, hex: String| { + let color3_from_hex = |_: &Lua, hex: String| { let trimmed = hex.trim_start_matches('#').to_ascii_uppercase(); let chars = if trimmed.len() == 3 { ( @@ -94,7 +94,7 @@ impl LuaExportsTable<'_> for Color3 { } }; - let color3_new = |_, (r, g, b): (Option, Option, Option)| { + let color3_new = |_: &Lua, (r, g, b): (Option, Option, Option)| { Ok(Color3 { r: r.unwrap_or_default(), g: g.unwrap_or_default(), @@ -111,14 +111,14 @@ impl LuaExportsTable<'_> for Color3 { } } -impl<'lua> FromLua<'lua> for Color3 { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for Color3 { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::UserData(ud) = value { Ok(*ud.borrow::()?) } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "Color3", + to: "Color3".to_string(), message: None, }) } @@ -126,13 +126,13 @@ impl<'lua> FromLua<'lua> for Color3 { } impl LuaUserData for Color3 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("R", |_, this| Ok(this.r)); fields.add_field_method_get("G", |_, this| Ok(this.g)); fields.add_field_method_get("B", |_, this| Ok(this.b)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method( "Lerp", diff --git a/crates/lune-roblox/src/datatypes/types/color_sequence.rs b/crates/lune-roblox/src/datatypes/types/color_sequence.rs index f2cc1b4..a1467ee 100644 --- a/crates/lune-roblox/src/datatypes/types/color_sequence.rs +++ b/crates/lune-roblox/src/datatypes/types/color_sequence.rs @@ -21,15 +21,15 @@ pub struct ColorSequence { pub(crate) keypoints: Vec, } -impl LuaExportsTable<'_> for ColorSequence { +impl LuaExportsTable for ColorSequence { const EXPORT_NAME: &'static str = "ColorSequence"; - fn create_exports_table(lua: &Lua) -> LuaResult { - type ArgsColor<'lua> = LuaUserDataRef<'lua, Color3>; - type ArgsColors<'lua> = (LuaUserDataRef<'lua, Color3>, LuaUserDataRef<'lua, Color3>); - type ArgsKeypoints<'lua> = Vec>; + fn create_exports_table(lua: Lua) -> LuaResult { + type ArgsColor = LuaUserDataRef; + type ArgsColors = (LuaUserDataRef, LuaUserDataRef); + type ArgsKeypoints = Vec>; - let color_sequence_new = |lua, args: LuaMultiValue| { + let color_sequence_new = |lua: &Lua, args: LuaMultiValue| { if let Ok(color) = ArgsColor::from_lua_multi(args.clone(), lua) { Ok(ColorSequence { keypoints: vec![ @@ -75,11 +75,11 @@ impl LuaExportsTable<'_> for ColorSequence { } impl LuaUserData for ColorSequence { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Keypoints", |_, this| Ok(this.keypoints.clone())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/color_sequence_keypoint.rs b/crates/lune-roblox/src/datatypes/types/color_sequence_keypoint.rs index c52b30e..922be73 100644 --- a/crates/lune-roblox/src/datatypes/types/color_sequence_keypoint.rs +++ b/crates/lune-roblox/src/datatypes/types/color_sequence_keypoint.rs @@ -20,16 +20,17 @@ pub struct ColorSequenceKeypoint { pub(crate) color: Color3, } -impl LuaExportsTable<'_> for ColorSequenceKeypoint { +impl LuaExportsTable for ColorSequenceKeypoint { const EXPORT_NAME: &'static str = "ColorSequenceKeypoint"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let color_sequence_keypoint_new = |_, (time, color): (f32, LuaUserDataRef)| { - Ok(ColorSequenceKeypoint { - time, - color: *color, - }) - }; + fn create_exports_table(lua: Lua) -> LuaResult { + let color_sequence_keypoint_new = + |_: &Lua, (time, color): (f32, LuaUserDataRef)| { + Ok(ColorSequenceKeypoint { + time, + color: *color, + }) + }; TableBuilder::new(lua)? .with_function("new", color_sequence_keypoint_new)? @@ -38,12 +39,12 @@ impl LuaExportsTable<'_> for ColorSequenceKeypoint { } impl LuaUserData for ColorSequenceKeypoint { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Time", |_, this| Ok(this.time)); fields.add_field_method_get("Value", |_, this| Ok(this.color)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/content.rs b/crates/lune-roblox/src/datatypes/types/content.rs index 226ea92..e773ba1 100644 --- a/crates/lune-roblox/src/datatypes/types/content.rs +++ b/crates/lune-roblox/src/datatypes/types/content.rs @@ -17,13 +17,13 @@ use super::{super::*, EnumItem}; #[derive(Debug, Clone, PartialEq)] pub struct Content(ContentType); -impl LuaExportsTable<'_> for Content { +impl LuaExportsTable for Content { const EXPORT_NAME: &'static str = "Content"; - fn create_exports_table(lua: &'_ Lua) -> LuaResult> { - let from_uri = |_, uri: String| Ok(Self(ContentType::Uri(uri))); + fn create_exports_table(lua: Lua) -> LuaResult { + let from_uri = |_: &Lua, uri: String| Ok(Self(ContentType::Uri(uri))); - let from_object = |_, obj: LuaUserDataRef| { + let from_object = |_: &Lua, obj: LuaUserDataRef| { let database = rbx_reflection_database::get(); let instance_descriptor = database .classes @@ -48,7 +48,7 @@ impl LuaExportsTable<'_> for Content { } impl LuaUserData for Content { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("SourceType", |_, this| { let variant_name = match &this.0 { ContentType::None => "None", @@ -81,14 +81,14 @@ impl LuaUserData for Content { }); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } } impl fmt::Display for Content { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { // Regardless of the actual content of the Content, Roblox just emits // `Content` when casting it to a string. We do not do that. write!(f, "Content(")?; diff --git a/crates/lune-roblox/src/datatypes/types/enum.rs b/crates/lune-roblox/src/datatypes/types/enum.rs index 4682f23..8c0a5ca 100644 --- a/crates/lune-roblox/src/datatypes/types/enum.rs +++ b/crates/lune-roblox/src/datatypes/types/enum.rs @@ -23,7 +23,7 @@ impl Enum { } impl LuaUserData for Enum { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("GetEnumItems", |_, this, ()| { Ok(this diff --git a/crates/lune-roblox/src/datatypes/types/enum_item.rs b/crates/lune-roblox/src/datatypes/types/enum_item.rs index c403f55..449b0f3 100644 --- a/crates/lune-roblox/src/datatypes/types/enum_item.rs +++ b/crates/lune-roblox/src/datatypes/types/enum_item.rs @@ -62,26 +62,26 @@ impl EnumItem { } impl LuaUserData for EnumItem { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Name", |_, this| Ok(this.name.clone())); fields.add_field_method_get("Value", |_, this| Ok(this.value)); fields.add_field_method_get("EnumType", |_, this| Ok(this.parent.clone())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } } -impl<'lua> FromLua<'lua> for EnumItem { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for EnumItem { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::UserData(ud) = value { Ok(ud.borrow::()?.to_owned()) } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "EnumItem", + to: "EnumItem".to_string(), message: None, }) } diff --git a/crates/lune-roblox/src/datatypes/types/enums.rs b/crates/lune-roblox/src/datatypes/types/enums.rs index 1a93597..173085d 100644 --- a/crates/lune-roblox/src/datatypes/types/enums.rs +++ b/crates/lune-roblox/src/datatypes/types/enums.rs @@ -13,7 +13,7 @@ use super::{super::*, Enum}; pub struct Enums; impl LuaUserData for Enums { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("GetEnums", |_, _, ()| { let db = rbx_reflection_database::get(); diff --git a/crates/lune-roblox/src/datatypes/types/faces.rs b/crates/lune-roblox/src/datatypes/types/faces.rs index 61a6cd9..7aeab5f 100644 --- a/crates/lune-roblox/src/datatypes/types/faces.rs +++ b/crates/lune-roblox/src/datatypes/types/faces.rs @@ -26,11 +26,11 @@ pub struct Faces { pub(crate) front: bool, } -impl LuaExportsTable<'_> for Faces { +impl LuaExportsTable for Faces { const EXPORT_NAME: &'static str = "Faces"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let faces_new = |_, args: LuaMultiValue| { + fn create_exports_table(lua: Lua) -> LuaResult { + let faces_new = |_: &Lua, args: LuaMultiValue| { let mut right = false; let mut top = false; let mut back = false; @@ -87,7 +87,7 @@ impl LuaExportsTable<'_> for Faces { } impl LuaUserData for Faces { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Right", |_, this| Ok(this.right)); fields.add_field_method_get("Top", |_, this| Ok(this.top)); fields.add_field_method_get("Back", |_, this| Ok(this.back)); @@ -96,7 +96,7 @@ impl LuaUserData for Faces { fields.add_field_method_get("Front", |_, this| Ok(this.front)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/font.rs b/crates/lune-roblox/src/datatypes/types/font.rs index 8848fea..2cefa91 100644 --- a/crates/lune-roblox/src/datatypes/types/font.rs +++ b/crates/lune-roblox/src/datatypes/types/font.rs @@ -40,11 +40,11 @@ impl Font { } } -impl LuaExportsTable<'_> for Font { +impl LuaExportsTable for Font { const EXPORT_NAME: &'static str = "Font"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let font_from_enum = |_, value: LuaUserDataRef| { + fn create_exports_table(lua: Lua) -> LuaResult { + let font_from_enum = |_: &Lua, value: LuaUserDataRef| { if value.parent.desc.name == "Font" { match Font::from_enum_item(&value) { Some(props) => Ok(props), @@ -62,7 +62,7 @@ impl LuaExportsTable<'_> for Font { }; let font_from_name = - |_, (file, weight, style): (String, Option, Option)| { + |_: &Lua, (file, weight, style): (String, Option, Option)| { Ok(Font { family: format!("rbxasset://fonts/families/{file}.json"), weight: weight.unwrap_or_default(), @@ -72,7 +72,7 @@ impl LuaExportsTable<'_> for Font { }; let font_from_id = - |_, (id, weight, style): (i32, Option, Option)| { + |_: &Lua, (id, weight, style): (i32, Option, Option)| { Ok(Font { family: format!("rbxassetid://{id}"), weight: weight.unwrap_or_default(), @@ -82,7 +82,7 @@ impl LuaExportsTable<'_> for Font { }; let font_new = - |_, (family, weight, style): (String, Option, Option)| { + |_: &Lua, (family, weight, style): (String, Option, Option)| { Ok(Font { family, weight: weight.unwrap_or_default(), @@ -101,7 +101,7 @@ impl LuaExportsTable<'_> for Font { } impl LuaUserData for Font { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { // Getters fields.add_field_method_get("Family", |_, this| Ok(this.family.clone())); fields.add_field_method_get("Weight", |_, this| Ok(this.weight)); @@ -126,7 +126,7 @@ impl LuaUserData for Font { }); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } @@ -282,8 +282,8 @@ impl std::fmt::Display for FontWeight { } } -impl<'lua> FromLua<'lua> for FontWeight { - fn from_lua(lua_value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for FontWeight { + fn from_lua(lua_value: LuaValue, _: &Lua) -> LuaResult { let mut message = None; if let LuaValue::UserData(ud) = &lua_value { let value = ud.borrow::()?; @@ -304,18 +304,18 @@ impl<'lua> FromLua<'lua> for FontWeight { } Err(LuaError::FromLuaConversionError { from: lua_value.type_name(), - to: "Enum.FontWeight", + to: "Enum.FontWeight".to_string(), message, }) } } -impl<'lua> IntoLua<'lua> for FontWeight { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for FontWeight { + fn into_lua(self, lua: &Lua) -> LuaResult { match EnumItem::from_enum_name_and_name("FontWeight", self.to_string()) { Some(enum_item) => Ok(LuaValue::UserData(lua.create_userdata(enum_item)?)), None => Err(LuaError::ToLuaConversionError { - from: "FontWeight", + from: "FontWeight".to_string(), to: "EnumItem", message: Some(format!("Found unknown Enum.FontWeight value '{self}'")), }), @@ -376,8 +376,8 @@ impl std::fmt::Display for FontStyle { } } -impl<'lua> FromLua<'lua> for FontStyle { - fn from_lua(lua_value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for FontStyle { + fn from_lua(lua_value: LuaValue, _: &Lua) -> LuaResult { let mut message = None; if let LuaValue::UserData(ud) = &lua_value { let value = ud.borrow::()?; @@ -398,18 +398,18 @@ impl<'lua> FromLua<'lua> for FontStyle { } Err(LuaError::FromLuaConversionError { from: lua_value.type_name(), - to: "Enum.FontStyle", + to: "Enum.FontStyle".to_string(), message, }) } } -impl<'lua> IntoLua<'lua> for FontStyle { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for FontStyle { + fn into_lua(self, lua: &Lua) -> LuaResult { match EnumItem::from_enum_name_and_name("FontStyle", self.to_string()) { Some(enum_item) => Ok(LuaValue::UserData(lua.create_userdata(enum_item)?)), None => Err(LuaError::ToLuaConversionError { - from: "FontStyle", + from: "FontStyle".to_string(), to: "EnumItem", message: Some(format!("Found unknown Enum.FontStyle value '{self}'")), }), diff --git a/crates/lune-roblox/src/datatypes/types/number_range.rs b/crates/lune-roblox/src/datatypes/types/number_range.rs index ad839d6..31666cc 100644 --- a/crates/lune-roblox/src/datatypes/types/number_range.rs +++ b/crates/lune-roblox/src/datatypes/types/number_range.rs @@ -20,11 +20,11 @@ pub struct NumberRange { pub(crate) max: f32, } -impl LuaExportsTable<'_> for NumberRange { +impl LuaExportsTable for NumberRange { const EXPORT_NAME: &'static str = "NumberRange"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let number_range_new = |_, (min, max): (f32, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let number_range_new = |_: &Lua, (min, max): (f32, Option)| { Ok(match max { Some(max) => NumberRange { min: min.min(max), @@ -41,12 +41,12 @@ impl LuaExportsTable<'_> for NumberRange { } impl LuaUserData for NumberRange { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Min", |_, this| Ok(this.min)); fields.add_field_method_get("Max", |_, this| Ok(this.max)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/number_sequence.rs b/crates/lune-roblox/src/datatypes/types/number_sequence.rs index 12d7374..7f74c45 100644 --- a/crates/lune-roblox/src/datatypes/types/number_sequence.rs +++ b/crates/lune-roblox/src/datatypes/types/number_sequence.rs @@ -21,15 +21,15 @@ pub struct NumberSequence { pub(crate) keypoints: Vec, } -impl LuaExportsTable<'_> for NumberSequence { +impl LuaExportsTable for NumberSequence { const EXPORT_NAME: &'static str = "NumberSequence"; - fn create_exports_table(lua: &Lua) -> LuaResult { + fn create_exports_table(lua: Lua) -> LuaResult { type ArgsColor = f32; type ArgsColors = (f32, f32); - type ArgsKeypoints<'lua> = Vec>; + type ArgsKeypoints = Vec>; - let number_sequence_new = |lua, args: LuaMultiValue| { + let number_sequence_new = |lua: &Lua, args: LuaMultiValue| { if let Ok(value) = ArgsColor::from_lua_multi(args.clone(), lua) { Ok(NumberSequence { keypoints: vec![ @@ -79,11 +79,11 @@ impl LuaExportsTable<'_> for NumberSequence { } impl LuaUserData for NumberSequence { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Keypoints", |_, this| Ok(this.keypoints.clone())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/number_sequence_keypoint.rs b/crates/lune-roblox/src/datatypes/types/number_sequence_keypoint.rs index 9ec43e5..ef2cf65 100644 --- a/crates/lune-roblox/src/datatypes/types/number_sequence_keypoint.rs +++ b/crates/lune-roblox/src/datatypes/types/number_sequence_keypoint.rs @@ -21,17 +21,18 @@ pub struct NumberSequenceKeypoint { pub(crate) envelope: f32, } -impl LuaExportsTable<'_> for NumberSequenceKeypoint { +impl LuaExportsTable for NumberSequenceKeypoint { const EXPORT_NAME: &'static str = "NumberSequenceKeypoint"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let number_sequence_keypoint_new = |_, (time, value, envelope): (f32, f32, Option)| { - Ok(NumberSequenceKeypoint { - time, - value, - envelope: envelope.unwrap_or_default(), - }) - }; + fn create_exports_table(lua: Lua) -> LuaResult { + let number_sequence_keypoint_new = + |_: &Lua, (time, value, envelope): (f32, f32, Option)| { + Ok(NumberSequenceKeypoint { + time, + value, + envelope: envelope.unwrap_or_default(), + }) + }; TableBuilder::new(lua)? .with_function("new", number_sequence_keypoint_new)? @@ -40,13 +41,13 @@ impl LuaExportsTable<'_> for NumberSequenceKeypoint { } impl LuaUserData for NumberSequenceKeypoint { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Time", |_, this| Ok(this.time)); fields.add_field_method_get("Value", |_, this| Ok(this.value)); fields.add_field_method_get("Envelope", |_, this| Ok(this.envelope)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/physical_properties.rs b/crates/lune-roblox/src/datatypes/types/physical_properties.rs index fd558eb..c719a8a 100644 --- a/crates/lune-roblox/src/datatypes/types/physical_properties.rs +++ b/crates/lune-roblox/src/datatypes/types/physical_properties.rs @@ -38,14 +38,14 @@ impl PhysicalProperties { } } -impl LuaExportsTable<'_> for PhysicalProperties { +impl LuaExportsTable for PhysicalProperties { const EXPORT_NAME: &'static str = "PhysicalProperties"; - fn create_exports_table(lua: &Lua) -> LuaResult { - type ArgsMaterial<'lua> = LuaUserDataRef<'lua, EnumItem>; + fn create_exports_table(lua: Lua) -> LuaResult { + type ArgsMaterial = LuaUserDataRef; type ArgsNumbers = (f32, f32, f32, Option, Option); - let physical_properties_new = |lua, args: LuaMultiValue| { + let physical_properties_new = |lua: &Lua, args: LuaMultiValue| { if let Ok(value) = ArgsMaterial::from_lua_multi(args.clone(), lua) { if value.parent.desc.name == "Material" { match PhysicalProperties::from_material(&value) { @@ -86,7 +86,7 @@ impl LuaExportsTable<'_> for PhysicalProperties { } impl LuaUserData for PhysicalProperties { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Density", |_, this| Ok(this.density)); fields.add_field_method_get("Friction", |_, this| Ok(this.friction)); fields.add_field_method_get("FrictionWeight", |_, this| Ok(this.friction_weight)); @@ -94,7 +94,7 @@ impl LuaUserData for PhysicalProperties { fields.add_field_method_get("ElasticityWeight", |_, this| Ok(this.elasticity_weight)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/ray.rs b/crates/lune-roblox/src/datatypes/types/ray.rs index 23a44d7..8b160be 100644 --- a/crates/lune-roblox/src/datatypes/types/ray.rs +++ b/crates/lune-roblox/src/datatypes/types/ray.rs @@ -32,12 +32,12 @@ impl Ray { } } -impl LuaExportsTable<'_> for Ray { +impl LuaExportsTable for Ray { const EXPORT_NAME: &'static str = "Ray"; - fn create_exports_table(lua: &Lua) -> LuaResult { + fn create_exports_table(lua: Lua) -> LuaResult { let ray_new = - |_, (origin, direction): (LuaUserDataRef, LuaUserDataRef)| { + |_: &Lua, (origin, direction): (LuaUserDataRef, LuaUserDataRef)| { Ok(Ray { origin: origin.0, direction: direction.0, @@ -51,7 +51,7 @@ impl LuaExportsTable<'_> for Ray { } impl LuaUserData for Ray { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Origin", |_, this| Ok(Vector3(this.origin))); fields.add_field_method_get("Direction", |_, this| Ok(Vector3(this.direction))); fields.add_field_method_get("Unit", |_, this| { @@ -62,7 +62,7 @@ impl LuaUserData for Ray { }); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("ClosestPoint", |_, this, to: LuaUserDataRef| { Ok(Vector3(this.closest_point(to.0))) diff --git a/crates/lune-roblox/src/datatypes/types/rect.rs b/crates/lune-roblox/src/datatypes/types/rect.rs index 0fa805c..fdfe777 100644 --- a/crates/lune-roblox/src/datatypes/types/rect.rs +++ b/crates/lune-roblox/src/datatypes/types/rect.rs @@ -32,17 +32,17 @@ impl Rect { } } -impl LuaExportsTable<'_> for Rect { +impl LuaExportsTable for Rect { const EXPORT_NAME: &'static str = "Rect"; - fn create_exports_table(lua: &Lua) -> LuaResult { - type ArgsVector2s<'lua> = ( - Option>, - Option>, + fn create_exports_table(lua: Lua) -> LuaResult { + type ArgsVector2s = ( + Option>, + Option>, ); type ArgsNums = (Option, Option, Option, Option); - let rect_new = |lua, args: LuaMultiValue| { + let rect_new = |lua: &Lua, args: LuaMultiValue| { if let Ok((min, max)) = ArgsVector2s::from_lua_multi(args.clone(), lua) { Ok(Rect::new( min.map(|m| *m).unwrap_or_default().0, @@ -67,14 +67,14 @@ impl LuaExportsTable<'_> for Rect { } impl LuaUserData for Rect { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Min", |_, this| Ok(Vector2(this.min))); fields.add_field_method_get("Max", |_, this| Ok(Vector2(this.max))); fields.add_field_method_get("Width", |_, this| Ok(this.max.x - this.min.x)); fields.add_field_method_get("Height", |_, this| Ok(this.max.y - this.min.y)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); methods.add_meta_method(LuaMetaMethod::Unm, userdata_impl_unm); diff --git a/crates/lune-roblox/src/datatypes/types/region3.rs b/crates/lune-roblox/src/datatypes/types/region3.rs index cb44df7..157307c 100644 --- a/crates/lune-roblox/src/datatypes/types/region3.rs +++ b/crates/lune-roblox/src/datatypes/types/region3.rs @@ -22,16 +22,17 @@ pub struct Region3 { pub(crate) max: Vec3, } -impl LuaExportsTable<'_> for Region3 { +impl LuaExportsTable for Region3 { const EXPORT_NAME: &'static str = "Region3"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let region3_new = |_, (min, max): (LuaUserDataRef, LuaUserDataRef)| { - Ok(Region3 { - min: min.0, - max: max.0, - }) - }; + fn create_exports_table(lua: Lua) -> LuaResult { + let region3_new = + |_: &Lua, (min, max): (LuaUserDataRef, LuaUserDataRef)| { + Ok(Region3 { + min: min.0, + max: max.0, + }) + }; TableBuilder::new(lua)? .with_function("new", region3_new)? @@ -40,14 +41,14 @@ impl LuaExportsTable<'_> for Region3 { } impl LuaUserData for Region3 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("CFrame", |_, this| { Ok(CFrame(Mat4::from_translation(this.min.lerp(this.max, 0.5)))) }); fields.add_field_method_get("Size", |_, this| Ok(Vector3(this.max - this.min))); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("ExpandToGrid", |_, this, resolution: f32| { Ok(Region3 { diff --git a/crates/lune-roblox/src/datatypes/types/region3int16.rs b/crates/lune-roblox/src/datatypes/types/region3int16.rs index 61075b0..f219f0c 100644 --- a/crates/lune-roblox/src/datatypes/types/region3int16.rs +++ b/crates/lune-roblox/src/datatypes/types/region3int16.rs @@ -22,12 +22,12 @@ pub struct Region3int16 { pub(crate) max: IVec3, } -impl LuaExportsTable<'_> for Region3int16 { +impl LuaExportsTable for Region3int16 { const EXPORT_NAME: &'static str = "Region3int16"; - fn create_exports_table(lua: &Lua) -> LuaResult { + fn create_exports_table(lua: Lua) -> LuaResult { let region3int16_new = - |_, (min, max): (LuaUserDataRef, LuaUserDataRef)| { + |_: &Lua, (min, max): (LuaUserDataRef, LuaUserDataRef)| { Ok(Region3int16 { min: min.0, max: max.0, @@ -41,12 +41,12 @@ impl LuaExportsTable<'_> for Region3int16 { } impl LuaUserData for Region3int16 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Min", |_, this| Ok(Vector3int16(this.min))); fields.add_field_method_get("Max", |_, this| Ok(Vector3int16(this.max))); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/datatypes/types/udim.rs b/crates/lune-roblox/src/datatypes/types/udim.rs index ac728e8..86c92b1 100644 --- a/crates/lune-roblox/src/datatypes/types/udim.rs +++ b/crates/lune-roblox/src/datatypes/types/udim.rs @@ -27,11 +27,11 @@ impl UDim { } } -impl LuaExportsTable<'_> for UDim { +impl LuaExportsTable for UDim { const EXPORT_NAME: &'static str = "UDim"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let udim_new = |_, (scale, offset): (Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let udim_new = |_: &Lua, (scale, offset): (Option, Option)| { Ok(UDim { scale: scale.unwrap_or_default(), offset: offset.unwrap_or_default(), @@ -45,12 +45,12 @@ impl LuaExportsTable<'_> for UDim { } impl LuaUserData for UDim { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Scale", |_, this| Ok(this.scale)); fields.add_field_method_get("Offset", |_, this| Ok(this.offset)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); methods.add_meta_method(LuaMetaMethod::Unm, userdata_impl_unm); diff --git a/crates/lune-roblox/src/datatypes/types/udim2.rs b/crates/lune-roblox/src/datatypes/types/udim2.rs index df78be4..93e09e0 100644 --- a/crates/lune-roblox/src/datatypes/types/udim2.rs +++ b/crates/lune-roblox/src/datatypes/types/udim2.rs @@ -24,30 +24,27 @@ pub struct UDim2 { pub(crate) y: UDim, } -impl LuaExportsTable<'_> for UDim2 { +impl LuaExportsTable for UDim2 { const EXPORT_NAME: &'static str = "UDim2"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let udim2_from_offset = |_, (x, y): (Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let udim2_from_offset = |_: &Lua, (x, y): (Option, Option)| { Ok(UDim2 { x: UDim::new(0f32, x.unwrap_or_default()), y: UDim::new(0f32, y.unwrap_or_default()), }) }; - let udim2_from_scale = |_, (x, y): (Option, Option)| { + let udim2_from_scale = |_: &Lua, (x, y): (Option, Option)| { Ok(UDim2 { x: UDim::new(x.unwrap_or_default(), 0), y: UDim::new(y.unwrap_or_default(), 0), }) }; - type ArgsUDims<'lua> = ( - Option>, - Option>, - ); + type ArgsUDims = (Option>, Option>); type ArgsNums = (Option, Option, Option, Option); - let udim2_new = |lua, args: LuaMultiValue| { + let udim2_new = |lua: &Lua, args: LuaMultiValue| { if let Ok((x, y)) = ArgsUDims::from_lua_multi(args.clone(), lua) { Ok(UDim2 { x: x.map(|x| *x).unwrap_or_default(), @@ -75,14 +72,14 @@ impl LuaExportsTable<'_> for UDim2 { } impl LuaUserData for UDim2 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("X", |_, this| Ok(this.x)); fields.add_field_method_get("Y", |_, this| Ok(this.y)); fields.add_field_method_get("Width", |_, this| Ok(this.x)); fields.add_field_method_get("Height", |_, this| Ok(this.y)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method( "Lerp", diff --git a/crates/lune-roblox/src/datatypes/types/vector2.rs b/crates/lune-roblox/src/datatypes/types/vector2.rs index 2248530..8c5afa5 100644 --- a/crates/lune-roblox/src/datatypes/types/vector2.rs +++ b/crates/lune-roblox/src/datatypes/types/vector2.rs @@ -21,11 +21,11 @@ use super::super::*; #[derive(Debug, Clone, Copy, PartialEq, Default)] pub struct Vector2(pub Vec2); -impl LuaExportsTable<'_> for Vector2 { +impl LuaExportsTable for Vector2 { const EXPORT_NAME: &'static str = "Vector2"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let vector2_new = |_, (x, y): (Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let vector2_new = |_: &Lua, (x, y): (Option, Option)| { Ok(Vector2(Vec2 { x: x.unwrap_or_default(), y: y.unwrap_or_default(), @@ -43,14 +43,14 @@ impl LuaExportsTable<'_> for Vector2 { } impl LuaUserData for Vector2 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Magnitude", |_, this| Ok(this.0.length())); fields.add_field_method_get("Unit", |_, this| Ok(Vector2(this.0.normalize()))); fields.add_field_method_get("X", |_, this| Ok(this.0.x)); fields.add_field_method_get("Y", |_, this| Ok(this.0.y)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("Angle", |_, this, rhs: LuaUserDataRef| { Ok(this.0.angle_between(rhs.0)) diff --git a/crates/lune-roblox/src/datatypes/types/vector2int16.rs b/crates/lune-roblox/src/datatypes/types/vector2int16.rs index 31931a0..1f98a15 100644 --- a/crates/lune-roblox/src/datatypes/types/vector2int16.rs +++ b/crates/lune-roblox/src/datatypes/types/vector2int16.rs @@ -21,11 +21,11 @@ use super::super::*; #[derive(Debug, Clone, Copy, PartialEq)] pub struct Vector2int16(pub IVec2); -impl LuaExportsTable<'_> for Vector2int16 { +impl LuaExportsTable for Vector2int16 { const EXPORT_NAME: &'static str = "Vector2int16"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let vector2int16_new = |_, (x, y): (Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let vector2int16_new = |_: &Lua, (x, y): (Option, Option)| { Ok(Vector2int16(IVec2 { x: x.unwrap_or_default() as i32, y: y.unwrap_or_default() as i32, @@ -39,12 +39,12 @@ impl LuaExportsTable<'_> for Vector2int16 { } impl LuaUserData for Vector2int16 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("X", |_, this| Ok(this.0.x)); fields.add_field_method_get("Y", |_, this| Ok(this.0.y)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); methods.add_meta_method(LuaMetaMethod::Unm, userdata_impl_unm); diff --git a/crates/lune-roblox/src/datatypes/types/vector3.rs b/crates/lune-roblox/src/datatypes/types/vector3.rs index c976c54..a357287 100644 --- a/crates/lune-roblox/src/datatypes/types/vector3.rs +++ b/crates/lune-roblox/src/datatypes/types/vector3.rs @@ -24,11 +24,11 @@ use super::{super::*, EnumItem}; #[derive(Debug, Clone, Copy, PartialEq)] pub struct Vector3(pub Vec3); -impl LuaExportsTable<'_> for Vector3 { +impl LuaExportsTable for Vector3 { const EXPORT_NAME: &'static str = "Vector3"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let vector3_from_axis = |_, normal_id: LuaUserDataRef| { + fn create_exports_table(lua: Lua) -> LuaResult { + let vector3_from_axis = |_: &Lua, normal_id: LuaUserDataRef| { if normal_id.parent.desc.name == "Axis" { Ok(match normal_id.name.as_str() { "X" => Vector3(Vec3::X), @@ -48,7 +48,7 @@ impl LuaExportsTable<'_> for Vector3 { } }; - let vector3_from_normal_id = |_, normal_id: LuaUserDataRef| { + let vector3_from_normal_id = |_: &Lua, normal_id: LuaUserDataRef| { if normal_id.parent.desc.name == "NormalId" { Ok(match normal_id.name.as_str() { "Left" => Vector3(Vec3::X), @@ -71,7 +71,7 @@ impl LuaExportsTable<'_> for Vector3 { } }; - let vector3_new = |_, (x, y, z): (Option, Option, Option)| { + let vector3_new = |_: &Lua, (x, y, z): (Option, Option, Option)| { Ok(Vector3(Vec3 { x: x.unwrap_or_default(), y: y.unwrap_or_default(), @@ -93,7 +93,7 @@ impl LuaExportsTable<'_> for Vector3 { } impl LuaUserData for Vector3 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Magnitude", |_, this| Ok(this.0.length())); fields.add_field_method_get("Unit", |_, this| Ok(Vector3(this.0.normalize()))); fields.add_field_method_get("X", |_, this| Ok(this.0.x)); @@ -101,7 +101,7 @@ impl LuaUserData for Vector3 { fields.add_field_method_get("Z", |_, this| Ok(this.0.z)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Methods methods.add_method("Angle", |_, this, rhs: LuaUserDataRef| { Ok(this.0.angle_between(rhs.0)) diff --git a/crates/lune-roblox/src/datatypes/types/vector3int16.rs b/crates/lune-roblox/src/datatypes/types/vector3int16.rs index b8f4f31..097c52a 100644 --- a/crates/lune-roblox/src/datatypes/types/vector3int16.rs +++ b/crates/lune-roblox/src/datatypes/types/vector3int16.rs @@ -21,11 +21,11 @@ use super::super::*; #[derive(Debug, Clone, Copy, PartialEq)] pub struct Vector3int16(pub IVec3); -impl LuaExportsTable<'_> for Vector3int16 { +impl LuaExportsTable for Vector3int16 { const EXPORT_NAME: &'static str = "Vector3int16"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let vector3int16_new = |_, (x, y, z): (Option, Option, Option)| { + fn create_exports_table(lua: Lua) -> LuaResult { + let vector3int16_new = |_: &Lua, (x, y, z): (Option, Option, Option)| { Ok(Vector3int16(IVec3 { x: x.unwrap_or_default() as i32, y: y.unwrap_or_default() as i32, @@ -40,13 +40,13 @@ impl LuaExportsTable<'_> for Vector3int16 { } impl LuaUserData for Vector3int16 { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("X", |_, this| Ok(this.0.x)); fields.add_field_method_get("Y", |_, this| Ok(this.0.y)); fields.add_field_method_get("Z", |_, this| Ok(this.0.z)); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); methods.add_meta_method(LuaMetaMethod::Unm, userdata_impl_unm); diff --git a/crates/lune-roblox/src/exports.rs b/crates/lune-roblox/src/exports.rs index 2a8f834..8a749fc 100644 --- a/crates/lune-roblox/src/exports.rs +++ b/crates/lune-roblox/src/exports.rs @@ -18,10 +18,10 @@ use mlua::prelude::*; } } - impl LuaExportsTable<'_> for MyType { + impl LuaExportsTable for MyType { const EXPORT_NAME: &'static str = "MyType"; - fn create_exports_table(lua: &Lua) -> LuaResult { + fn create_exports_table(lua: Lua) -> LuaResult { let my_type_new = |lua, n: Option| { Self::new(n.unwrap_or_default()) }; @@ -37,10 +37,10 @@ use mlua::prelude::*; } ``` */ -pub trait LuaExportsTable<'lua> { +pub trait LuaExportsTable { const EXPORT_NAME: &'static str; - fn create_exports_table(lua: &'lua Lua) -> LuaResult>; + fn create_exports_table(lua: Lua) -> LuaResult; } /** @@ -57,12 +57,12 @@ pub trait LuaExportsTable<'lua> { let (name2, table2) = export::(lua)?; ``` */ -pub fn export<'lua, T>(lua: &'lua Lua) -> LuaResult<(&'static str, LuaValue<'lua>)> +pub fn export(lua: Lua) -> LuaResult<(&'static str, LuaValue)> where - T: LuaExportsTable<'lua>, + T: LuaExportsTable, { Ok(( T::EXPORT_NAME, - ::create_exports_table(lua)?.into_lua(lua)?, + ::create_exports_table(lua.clone())?.into_lua(&lua)?, )) } diff --git a/crates/lune-roblox/src/instance/base.rs b/crates/lune-roblox/src/instance/base.rs index 1a10096..cda65fd 100644 --- a/crates/lune-roblox/src/instance/base.rs +++ b/crates/lune-roblox/src/instance/base.rs @@ -20,7 +20,7 @@ use crate::{ use super::{data_model, registry::InstanceRegistry, Instance}; #[allow(clippy::too_many_lines)] -pub fn add_methods<'lua, M: LuaUserDataMethods<'lua, Instance>>(m: &mut M) { +pub fn add_methods>(m: &mut M) { m.add_meta_method(LuaMetaMethod::ToString, |lua, this, ()| { ensure_not_destroyed(this)?; userdata_impl_to_string(lua, this, ()) @@ -211,11 +211,7 @@ fn ensure_not_destroyed(inst: &Instance) -> LuaResult<()> { 3. Get a current child of the instance 4. No valid property or instance found, throw error */ -fn instance_property_get<'lua>( - lua: &'lua Lua, - this: &Instance, - prop_name: String, -) -> LuaResult> { +fn instance_property_get(lua: &Lua, this: &Instance, prop_name: String) -> LuaResult { match prop_name.as_str() { "ClassName" => return this.get_class_name().into_lua(lua), "Parent" => { @@ -295,10 +291,10 @@ fn instance_property_get<'lua>( 2a. Set a strict enum from a given EnumItem OR 2b. Set a normal property from a given value */ -fn instance_property_set<'lua>( - lua: &'lua Lua, +fn instance_property_set( + lua: &Lua, this: &mut Instance, - (prop_name, prop_value): (String, LuaValue<'lua>), + (prop_name, prop_value): (String, LuaValue), ) -> LuaResult<()> { ensure_not_destroyed(this)?; @@ -319,7 +315,7 @@ fn instance_property_set<'lua>( "Failed to set Parent - DataModel can not be reparented".to_string(), )); } - type Parent<'lua> = Option>; + type Parent = Option>; let parent = Parent::from_lua(prop_value, lua)?; this.set_parent(parent.map(|p| *p)); return Ok(()); diff --git a/crates/lune-roblox/src/instance/data_model.rs b/crates/lune-roblox/src/instance/data_model.rs index 6aebb8c..e6bdb06 100644 --- a/crates/lune-roblox/src/instance/data_model.rs +++ b/crates/lune-roblox/src/instance/data_model.rs @@ -12,11 +12,11 @@ use super::Instance; pub const CLASS_NAME: &str = "DataModel"; -pub fn add_fields<'lua, F: LuaUserDataFields<'lua, Instance>>(f: &mut F) { +pub fn add_fields>(f: &mut F) { add_class_restricted_getter(f, CLASS_NAME, "Workspace", data_model_get_workspace); } -pub fn add_methods<'lua, M: LuaUserDataMethods<'lua, Instance>>(m: &mut M) { +pub fn add_methods>(m: &mut M) { add_class_restricted_method(m, CLASS_NAME, "GetService", data_model_get_service); add_class_restricted_method(m, CLASS_NAME, "FindService", data_model_find_service); } diff --git a/crates/lune-roblox/src/instance/mod.rs b/crates/lune-roblox/src/instance/mod.rs index 0746a16..3484b72 100644 --- a/crates/lune-roblox/src/instance/mod.rs +++ b/crates/lune-roblox/src/instance/mod.rs @@ -723,11 +723,11 @@ impl Instance { } } -impl LuaExportsTable<'_> for Instance { +impl LuaExportsTable for Instance { const EXPORT_NAME: &'static str = "Instance"; - fn create_exports_table(lua: &Lua) -> LuaResult { - let instance_new = |lua, class_name: String| { + fn create_exports_table(lua: Lua) -> LuaResult { + let instance_new = |lua: &Lua, class_name: String| { if class_exists(&class_name) { Instance::new_orphaned(class_name).into_lua(lua) } else { @@ -756,12 +756,12 @@ impl LuaExportsTable<'_> for Instance { instance registry, and register properties + methods from the lua side */ impl LuaUserData for Instance { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { data_model::add_fields(fields); workspace::add_fields(fields); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { base::add_methods(methods); data_model::add_methods(methods); terrain::add_methods(methods); diff --git a/crates/lune-roblox/src/instance/registry.rs b/crates/lune-roblox/src/instance/registry.rs index 11aa175..a9f935f 100644 --- a/crates/lune-roblox/src/instance/registry.rs +++ b/crates/lune-roblox/src/instance/registry.rs @@ -58,11 +58,11 @@ impl InstanceRegistry { - If the method already exists in the registry. */ - pub fn insert_method<'lua>( - lua: &'lua Lua, + pub fn insert_method( + lua: &Lua, class_name: &str, method_name: &str, - method: LuaFunction<'lua>, + method: LuaFunction, ) -> Result<(), InstanceRegistryError> { let registry = Self::get_or_create(lua); @@ -94,11 +94,11 @@ impl InstanceRegistry { - If the property already exists in the registry. */ - pub fn insert_property_getter<'lua>( - lua: &'lua Lua, + pub fn insert_property_getter( + lua: &Lua, class_name: &str, property_name: &str, - property_getter: LuaFunction<'lua>, + property_getter: LuaFunction, ) -> Result<(), InstanceRegistryError> { let registry = Self::get_or_create(lua); @@ -130,11 +130,11 @@ impl InstanceRegistry { - If the property already exists in the registry. */ - pub fn insert_property_setter<'lua>( - lua: &'lua Lua, + pub fn insert_property_setter( + lua: &Lua, class_name: &str, property_name: &str, - property_setter: LuaFunction<'lua>, + property_setter: LuaFunction, ) -> Result<(), InstanceRegistryError> { let registry = Self::get_or_create(lua); @@ -165,11 +165,7 @@ impl InstanceRegistry { Returns `None` if the method is not found. */ #[must_use] - pub fn find_method<'lua>( - lua: &'lua Lua, - instance: &Instance, - method_name: &str, - ) -> Option> { + pub fn find_method(lua: &Lua, instance: &Instance, method_name: &str) -> Option { let registry = Self::get_or_create(lua); let methods = registry .methods @@ -192,11 +188,11 @@ impl InstanceRegistry { Returns `None` if the property getter is not found. */ #[must_use] - pub fn find_property_getter<'lua>( - lua: &'lua Lua, + pub fn find_property_getter( + lua: &Lua, instance: &Instance, property_name: &str, - ) -> Option> { + ) -> Option { let registry = Self::get_or_create(lua); let getters = registry .getters @@ -219,11 +215,11 @@ impl InstanceRegistry { Returns `None` if the property setter is not found. */ #[must_use] - pub fn find_property_setter<'lua>( - lua: &'lua Lua, + pub fn find_property_setter( + lua: &Lua, instance: &Instance, property_name: &str, - ) -> Option> { + ) -> Option { let registry = Self::get_or_create(lua); let setters = registry .setters diff --git a/crates/lune-roblox/src/instance/terrain.rs b/crates/lune-roblox/src/instance/terrain.rs index 8d77008..c53d9c8 100644 --- a/crates/lune-roblox/src/instance/terrain.rs +++ b/crates/lune-roblox/src/instance/terrain.rs @@ -10,7 +10,7 @@ use super::Instance; pub const CLASS_NAME: &str = "Terrain"; -pub fn add_methods<'lua, M: LuaUserDataMethods<'lua, Instance>>(methods: &mut M) { +pub fn add_methods>(methods: &mut M) { add_class_restricted_method( methods, CLASS_NAME, diff --git a/crates/lune-roblox/src/instance/workspace.rs b/crates/lune-roblox/src/instance/workspace.rs index f11cd8d..ff3087e 100644 --- a/crates/lune-roblox/src/instance/workspace.rs +++ b/crates/lune-roblox/src/instance/workspace.rs @@ -6,7 +6,7 @@ use super::Instance; pub const CLASS_NAME: &str = "Workspace"; -pub fn add_fields<'lua, F: LuaUserDataFields<'lua, Instance>>(f: &mut F) { +pub fn add_fields>(f: &mut F) { add_class_restricted_getter(f, CLASS_NAME, "Terrain", workspace_get_terrain); add_class_restricted_getter(f, CLASS_NAME, "CurrentCamera", workspace_get_camera); } diff --git a/crates/lune-roblox/src/lib.rs b/crates/lune-roblox/src/lib.rs index eefa73b..0c2d82d 100644 --- a/crates/lune-roblox/src/lib.rs +++ b/crates/lune-roblox/src/lib.rs @@ -14,38 +14,38 @@ pub(crate) mod shared; use exports::export; -fn create_all_exports(lua: &Lua) -> LuaResult> { +fn create_all_exports(lua: Lua) -> LuaResult> { use datatypes::types::*; use instance::Instance; Ok(vec![ // Datatypes - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, - export::(lua)?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, + export::(lua.clone())?, // Classes - export::(lua)?, + export::(lua.clone())?, // Singletons - ("Enum", Enums.into_lua(lua)?), + ("Enum", Enums.into_lua(&lua)?), ]) } @@ -59,13 +59,13 @@ fn create_all_exports(lua: &Lua) -> LuaResult> { Errors when out of memory or when a value cannot be created. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { // FUTURE: We can probably create these lazily as users // index the main exports (this return value) table and // save some memory and startup time. The full exports // table is quite big and probably won't get any smaller // since we impl all roblox constructors for each datatype. - let exports = create_all_exports(lua)?; + let exports = create_all_exports(lua.clone())?; TableBuilder::new(lua)? .with_values(exports)? .build_readonly() diff --git a/crates/lune-roblox/src/reflection/class.rs b/crates/lune-roblox/src/reflection/class.rs index f5b2aac..e9fd825 100644 --- a/crates/lune-roblox/src/reflection/class.rs +++ b/crates/lune-roblox/src/reflection/class.rs @@ -85,7 +85,7 @@ impl DatabaseClass { } impl LuaUserData for DatabaseClass { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Name", |_, this| Ok(this.get_name())); fields.add_field_method_get("Superclass", |_, this| Ok(this.get_superclass())); fields.add_field_method_get("Properties", |_, this| Ok(this.get_properties())); @@ -108,7 +108,7 @@ impl LuaUserData for DatabaseClass { fields.add_field_method_get("Tags", |_, this| Ok(this.get_tags_str())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/reflection/enums.rs b/crates/lune-roblox/src/reflection/enums.rs index 62f786c..50b1a46 100644 --- a/crates/lune-roblox/src/reflection/enums.rs +++ b/crates/lune-roblox/src/reflection/enums.rs @@ -45,12 +45,12 @@ impl DatabaseEnum { } impl LuaUserData for DatabaseEnum { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Name", |_, this| Ok(this.get_name())); fields.add_field_method_get("Items", |_, this| Ok(this.get_items())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/reflection/mod.rs b/crates/lune-roblox/src/reflection/mod.rs index 9bb2203..165714e 100644 --- a/crates/lune-roblox/src/reflection/mod.rs +++ b/crates/lune-roblox/src/reflection/mod.rs @@ -111,11 +111,11 @@ impl Database { } impl LuaUserData for Database { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Version", |_, this| Ok(this.get_version())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); methods.add_method("GetEnumNames", |_, this, (): ()| Ok(this.get_enum_names())); diff --git a/crates/lune-roblox/src/reflection/property.rs b/crates/lune-roblox/src/reflection/property.rs index 3e169b3..3ef6afd 100644 --- a/crates/lune-roblox/src/reflection/property.rs +++ b/crates/lune-roblox/src/reflection/property.rs @@ -69,14 +69,14 @@ impl DatabaseProperty { } impl LuaUserData for DatabaseProperty { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("Name", |_, this| Ok(this.get_name())); fields.add_field_method_get("Datatype", |_, this| Ok(this.get_datatype_name())); fields.add_field_method_get("Scriptability", |_, this| Ok(this.get_scriptability_str())); fields.add_field_method_get("Tags", |_, this| Ok(this.get_tags_str())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Eq, userdata_impl_eq); methods.add_meta_method(LuaMetaMethod::ToString, userdata_impl_to_string); } diff --git a/crates/lune-roblox/src/shared/classes.rs b/crates/lune-roblox/src/shared/classes.rs index d1e2c69..13a0113 100644 --- a/crates/lune-roblox/src/shared/classes.rs +++ b/crates/lune-roblox/src/shared/classes.rs @@ -6,14 +6,14 @@ use crate::instance::Instance; use super::instance::class_is_a; -pub(crate) fn add_class_restricted_getter<'lua, F: LuaUserDataFields<'lua, Instance>, R, G>( +pub(crate) fn add_class_restricted_getter, R, G>( fields: &mut F, class_name: &'static str, field_name: &'static str, field_getter: G, ) where - R: IntoLua<'lua>, - G: 'static + Fn(&'lua Lua, &Instance) -> LuaResult, + R: IntoLua, + G: 'static + Fn(&Lua, &Instance) -> LuaResult, { fields.add_field_method_get(field_name, move |lua, this| { if class_is_a(this.get_class_name(), class_name).unwrap_or(false) { @@ -27,14 +27,14 @@ pub(crate) fn add_class_restricted_getter<'lua, F: LuaUserDataFields<'lua, Insta } #[allow(dead_code)] -pub(crate) fn add_class_restricted_setter<'lua, F: LuaUserDataFields<'lua, Instance>, A, G>( +pub(crate) fn add_class_restricted_setter, A, G>( fields: &mut F, class_name: &'static str, field_name: &'static str, field_getter: G, ) where - A: FromLua<'lua>, - G: 'static + Fn(&'lua Lua, &Instance, A) -> LuaResult<()>, + A: FromLua, + G: 'static + Fn(&Lua, &Instance, A) -> LuaResult<()>, { fields.add_field_method_set(field_name, move |lua, this, value| { if class_is_a(this.get_class_name(), class_name).unwrap_or(false) { @@ -47,15 +47,15 @@ pub(crate) fn add_class_restricted_setter<'lua, F: LuaUserDataFields<'lua, Insta }); } -pub(crate) fn add_class_restricted_method<'lua, M: LuaUserDataMethods<'lua, Instance>, A, R, F>( +pub(crate) fn add_class_restricted_method, A, R, F>( methods: &mut M, class_name: &'static str, method_name: &'static str, method: F, ) where - A: FromLuaMulti<'lua>, - R: IntoLuaMulti<'lua>, - F: 'static + Fn(&'lua Lua, &Instance, A) -> LuaResult, + A: FromLuaMulti, + R: IntoLuaMulti, + F: 'static + Fn(&Lua, &Instance, A) -> LuaResult, { methods.add_method(method_name, move |lua, this, args| { if class_is_a(this.get_class_name(), class_name).unwrap_or(false) { @@ -68,21 +68,15 @@ pub(crate) fn add_class_restricted_method<'lua, M: LuaUserDataMethods<'lua, Inst }); } -pub(crate) fn add_class_restricted_method_mut< - 'lua, - M: LuaUserDataMethods<'lua, Instance>, - A, - R, - F, ->( +pub(crate) fn add_class_restricted_method_mut, A, R, F>( methods: &mut M, class_name: &'static str, method_name: &'static str, method: F, ) where - A: FromLuaMulti<'lua>, - R: IntoLuaMulti<'lua>, - F: 'static + Fn(&'lua Lua, &mut Instance, A) -> LuaResult, + A: FromLuaMulti, + R: IntoLuaMulti, + F: 'static + Fn(&Lua, &mut Instance, A) -> LuaResult, { methods.add_method_mut(method_name, move |lua, this, args| { if class_is_a(this.get_class_name(), class_name).unwrap_or(false) { diff --git a/crates/lune-roblox/src/shared/userdata.rs b/crates/lune-roblox/src/shared/userdata.rs index 204d45a..803c2e0 100644 --- a/crates/lune-roblox/src/shared/userdata.rs +++ b/crates/lune-roblox/src/shared/userdata.rs @@ -90,7 +90,7 @@ where } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: type_name::(), + to: type_name::().to_string(), message: Some(format!( "Expected {} or number, got {}", type_name::(), @@ -115,7 +115,7 @@ where } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: type_name::(), + to: type_name::().to_string(), message: Some(format!( "Expected {} or number, got {}", type_name::(), @@ -140,7 +140,7 @@ where } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: type_name::(), + to: type_name::().to_string(), message: Some(format!( "Expected {} or number, got {}", type_name::(), @@ -171,7 +171,7 @@ where } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: type_name::(), + to: type_name::().to_string(), message: Some(format!( "Expected {} or number, got {}", type_name::(), @@ -196,7 +196,7 @@ where } Err(LuaError::FromLuaConversionError { from: rhs.type_name(), - to: type_name::(), + to: type_name::().to_string(), message: Some(format!( "Expected {} or number, got {}", type_name::(), diff --git a/crates/lune-std-datetime/Cargo.toml b/crates/lune-std-datetime/Cargo.toml index b68b9ed..7a367bb 100644 --- a/crates/lune-std-datetime/Cargo.toml +++ b/crates/lune-std-datetime/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } thiserror = "1.0" chrono = "0.4.38" diff --git a/crates/lune-std-datetime/src/date_time.rs b/crates/lune-std-datetime/src/date_time.rs index c72bbc4..3733d5f 100644 --- a/crates/lune-std-datetime/src/date_time.rs +++ b/crates/lune-std-datetime/src/date_time.rs @@ -228,14 +228,14 @@ impl DateTime { } impl LuaUserData for DateTime { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("unixTimestamp", |_, this| Ok(this.inner.timestamp())); fields.add_field_method_get("unixTimestampMillis", |_, this| { Ok(this.inner.timestamp_millis()) }); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { // Metamethods to compare DateTime as instants in time methods.add_meta_method( LuaMetaMethod::Eq, diff --git a/crates/lune-std-datetime/src/lib.rs b/crates/lune-std-datetime/src/lib.rs index cf01719..d2891a3 100644 --- a/crates/lune-std-datetime/src/lib.rs +++ b/crates/lune-std-datetime/src/lib.rs @@ -17,7 +17,7 @@ pub use self::date_time::DateTime; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_function("fromIsoDate", |_, iso_date: String| { Ok(DateTime::from_iso_date(iso_date)?) diff --git a/crates/lune-std-datetime/src/values.rs b/crates/lune-std-datetime/src/values.rs index 6028507..c66fc25 100644 --- a/crates/lune-std-datetime/src/values.rs +++ b/crates/lune-std-datetime/src/values.rs @@ -68,12 +68,12 @@ where a fixed point in time, and we guarantee that it doesn't change */ -impl FromLua<'_> for DateTimeValues { +impl FromLua for DateTimeValues { fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if !value.is_table() { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "DateTimeValues", + to: "DateTimeValues".to_string(), message: Some("value must be a table".to_string()), }); } @@ -93,16 +93,16 @@ impl FromLua<'_> for DateTimeValues { Ok(dt) => Ok(dt), Err(e) => Err(LuaError::FromLuaConversionError { from: "table", - to: "DateTimeValues", + to: "DateTimeValues".to_string(), message: Some(e.to_string()), }), } } } -impl IntoLua<'_> for DateTimeValues { +impl IntoLua for DateTimeValues { fn into_lua(self, lua: &Lua) -> LuaResult { - let tab = TableBuilder::new(lua)? + let tab = TableBuilder::new(lua.clone())? .with_value("year", self.year)? .with_values(vec![ ("month", self.month), diff --git a/crates/lune-std-fs/Cargo.toml b/crates/lune-std-fs/Cargo.toml index 69f45f2..23eb468 100644 --- a/crates/lune-std-fs/Cargo.toml +++ b/crates/lune-std-fs/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } bstr = "1.9" diff --git a/crates/lune-std-fs/src/lib.rs b/crates/lune-std-fs/src/lib.rs index a50a9b6..27e4b89 100755 --- a/crates/lune-std-fs/src/lib.rs +++ b/crates/lune-std-fs/src/lib.rs @@ -24,7 +24,7 @@ use self::options::FsWriteOptions; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_async_function("readFile", fs_read_file)? .with_async_function("readDir", fs_read_dir)? @@ -40,13 +40,13 @@ pub fn module(lua: &Lua) -> LuaResult { .build_readonly() } -async fn fs_read_file(lua: &Lua, path: String) -> LuaResult { +async fn fs_read_file(lua: Lua, path: String) -> LuaResult { let bytes = fs::read(&path).await.into_lua_err()?; lua.create_string(bytes) } -async fn fs_read_dir(_: &Lua, path: String) -> LuaResult> { +async fn fs_read_dir(_: Lua, path: String) -> LuaResult> { let mut dir_strings = Vec::new(); let mut dir = fs::read_dir(&path).await.into_lua_err()?; while let Some(dir_entry) = dir.next_entry().await.into_lua_err()? { @@ -62,23 +62,23 @@ async fn fs_read_dir(_: &Lua, path: String) -> LuaResult> { Ok(dir_strings) } -async fn fs_write_file(_: &Lua, (path, contents): (String, BString)) -> LuaResult<()> { +async fn fs_write_file(_: Lua, (path, contents): (String, BString)) -> LuaResult<()> { fs::write(&path, contents.as_bytes()).await.into_lua_err() } -async fn fs_write_dir(_: &Lua, path: String) -> LuaResult<()> { +async fn fs_write_dir(_: Lua, path: String) -> LuaResult<()> { fs::create_dir_all(&path).await.into_lua_err() } -async fn fs_remove_file(_: &Lua, path: String) -> LuaResult<()> { +async fn fs_remove_file(_: Lua, path: String) -> LuaResult<()> { fs::remove_file(&path).await.into_lua_err() } -async fn fs_remove_dir(_: &Lua, path: String) -> LuaResult<()> { +async fn fs_remove_dir(_: Lua, path: String) -> LuaResult<()> { fs::remove_dir_all(&path).await.into_lua_err() } -async fn fs_metadata(_: &Lua, path: String) -> LuaResult { +async fn fs_metadata(_: Lua, path: String) -> LuaResult { match fs::metadata(path).await { Err(e) if e.kind() == IoErrorKind::NotFound => Ok(FsMetadata::not_found()), Ok(meta) => Ok(FsMetadata::from(meta)), @@ -86,7 +86,7 @@ async fn fs_metadata(_: &Lua, path: String) -> LuaResult { } } -async fn fs_is_file(_: &Lua, path: String) -> LuaResult { +async fn fs_is_file(_: Lua, path: String) -> LuaResult { match fs::metadata(path).await { Err(e) if e.kind() == IoErrorKind::NotFound => Ok(false), Ok(meta) => Ok(meta.is_file()), @@ -94,7 +94,7 @@ async fn fs_is_file(_: &Lua, path: String) -> LuaResult { } } -async fn fs_is_dir(_: &Lua, path: String) -> LuaResult { +async fn fs_is_dir(_: Lua, path: String) -> LuaResult { match fs::metadata(path).await { Err(e) if e.kind() == IoErrorKind::NotFound => Ok(false), Ok(meta) => Ok(meta.is_dir()), @@ -102,7 +102,7 @@ async fn fs_is_dir(_: &Lua, path: String) -> LuaResult { } } -async fn fs_move(_: &Lua, (from, to, options): (String, String, FsWriteOptions)) -> LuaResult<()> { +async fn fs_move(_: Lua, (from, to, options): (String, String, FsWriteOptions)) -> LuaResult<()> { let path_from = PathBuf::from(from); if !path_from.exists() { return Err(LuaError::RuntimeError(format!( @@ -121,6 +121,6 @@ async fn fs_move(_: &Lua, (from, to, options): (String, String, FsWriteOptions)) Ok(()) } -async fn fs_copy(_: &Lua, (from, to, options): (String, String, FsWriteOptions)) -> LuaResult<()> { +async fn fs_copy(_: Lua, (from, to, options): (String, String, FsWriteOptions)) -> LuaResult<()> { copy(from, to, options).await } diff --git a/crates/lune-std-fs/src/metadata.rs b/crates/lune-std-fs/src/metadata.rs index 2cf01c8..ea14b41 100644 --- a/crates/lune-std-fs/src/metadata.rs +++ b/crates/lune-std-fs/src/metadata.rs @@ -61,8 +61,8 @@ impl From for FsMetadataKind { } } -impl<'lua> IntoLua<'lua> for FsMetadataKind { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for FsMetadataKind { + fn into_lua(self, lua: &Lua) -> LuaResult { if self == Self::None { Ok(LuaValue::Nil) } else { @@ -84,8 +84,8 @@ impl From for FsPermissions { } } -impl<'lua> IntoLua<'lua> for FsPermissions { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for FsPermissions { + fn into_lua(self, lua: &Lua) -> LuaResult { let tab = lua.create_table_with_capacity(0, 1)?; tab.set("readOnly", self.read_only)?; tab.set_readonly(true); @@ -116,8 +116,8 @@ impl FsMetadata { } } -impl<'lua> IntoLua<'lua> for FsMetadata { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for FsMetadata { + fn into_lua(self, lua: &Lua) -> LuaResult { let tab = lua.create_table_with_capacity(0, 6)?; tab.set("kind", self.kind)?; tab.set("exists", self.exists)?; diff --git a/crates/lune-std-fs/src/options.rs b/crates/lune-std-fs/src/options.rs index d33c8f4..4b5b9f3 100644 --- a/crates/lune-std-fs/src/options.rs +++ b/crates/lune-std-fs/src/options.rs @@ -5,8 +5,8 @@ pub struct FsWriteOptions { pub(crate) overwrite: bool, } -impl<'lua> FromLua<'lua> for FsWriteOptions { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for FsWriteOptions { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { Ok(match value { LuaValue::Nil => Self { overwrite: false }, LuaValue::Boolean(b) => Self { overwrite: b }, @@ -19,7 +19,7 @@ impl<'lua> FromLua<'lua> for FsWriteOptions { _ => { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "FsWriteOptions", + to: "FsWriteOptions".to_string(), message: Some(format!( "Invalid write options - expected boolean or table, got {}", value.type_name() diff --git a/crates/lune-std-luau/Cargo.toml b/crates/lune-std-luau/Cargo.toml index 966a5c9..2dbfe41 100644 --- a/crates/lune-std-luau/Cargo.toml +++ b/crates/lune-std-luau/Cargo.toml @@ -13,6 +13,6 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau", "luau-jit"] } +mlua = { version = "0.10.3", features = ["luau", "luau-jit"] } lune-utils = { version = "0.1.3", path = "../lune-utils" } diff --git a/crates/lune-std-luau/src/lib.rs b/crates/lune-std-luau/src/lib.rs index f3a61bd..5ddf65c 100644 --- a/crates/lune-std-luau/src/lib.rs +++ b/crates/lune-std-luau/src/lib.rs @@ -2,14 +2,12 @@ use mlua::prelude::*; -use lune_utils::{jit::JitStatus, TableBuilder}; +use lune_utils::{jit::JitEnablement, TableBuilder}; mod options; use self::options::{LuauCompileOptions, LuauLoadOptions}; -const BYTECODE_ERROR_BYTE: u8 = 0; - /** Creates the `luau` standard library module. @@ -17,33 +15,30 @@ const BYTECODE_ERROR_BYTE: u8 = 0; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_function("compile", compile_source)? .with_function("load", load_source)? .build_readonly() } -fn compile_source<'lua>( - lua: &'lua Lua, - (source, options): (LuaString<'lua>, LuauCompileOptions), -) -> LuaResult> { - let bytecode = options.into_compiler().compile(source); - - match bytecode.first() { - Some(&BYTECODE_ERROR_BYTE) => Err(LuaError::RuntimeError( - String::from_utf8_lossy(&bytecode).into_owned(), - )), - Some(_) => lua.create_string(bytecode), - None => panic!("Compiling resulted in empty bytecode"), - } +fn compile_source( + lua: &Lua, + (source, options): (LuaString, LuauCompileOptions), +) -> LuaResult { + options + .into_compiler() + .compile(source.as_bytes()) + .and_then(|s| lua.create_string(s)) } -fn load_source<'lua>( - lua: &'lua Lua, - (source, options): (LuaString<'lua>, LuauLoadOptions), -) -> LuaResult> { - let mut chunk = lua.load(source.as_bytes()).set_name(options.debug_name); +fn load_source( + lua: &Lua, + (source, options): (LuaString, LuauLoadOptions), +) -> LuaResult { + let mut chunk = lua + .load(source.as_bytes().to_vec()) + .set_name(options.debug_name); let env_changed = options.environment.is_some(); if let Some(custom_environment) = options.environment { @@ -56,10 +51,10 @@ fn load_source<'lua>( environment.set(key, value)?; } - if let Some(global_metatable) = lua.globals().get_metatable() { + if let Some(global_metatable) = lua.globals().metatable() { environment.set_metatable(Some(global_metatable)); } - } else if let Some(custom_metatable) = custom_environment.get_metatable() { + } else if let Some(custom_metatable) = custom_environment.metatable() { // Since we don't need to set the global metatable, // we can just set a custom metatable if it exists environment.set_metatable(Some(custom_metatable)); @@ -79,7 +74,7 @@ fn load_source<'lua>( lua.enable_jit(options.codegen_enabled && !env_changed); let function = chunk.into_function()?; lua.enable_jit( - lua.app_data_ref::() + lua.app_data_ref::() .ok_or(LuaError::runtime( "Failed to get current JitStatus ref from AppData", ))? diff --git a/crates/lune-std-luau/src/options.rs b/crates/lune-std-luau/src/options.rs index 81b8ac0..7c0d080 100644 --- a/crates/lune-std-luau/src/options.rs +++ b/crates/lune-std-luau/src/options.rs @@ -36,8 +36,8 @@ impl Default for LuauCompileOptions { } } -impl<'lua> FromLua<'lua> for LuauCompileOptions { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for LuauCompileOptions { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { Ok(match value { LuaValue::Nil => Self::default(), LuaValue::Table(t) => { @@ -68,7 +68,7 @@ impl<'lua> FromLua<'lua> for LuauCompileOptions { _ => { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "CompileOptions", + to: "CompileOptions".to_string(), message: Some(format!( "Invalid compile options - expected table, got {}", value.type_name() @@ -79,14 +79,14 @@ impl<'lua> FromLua<'lua> for LuauCompileOptions { } } -pub struct LuauLoadOptions<'lua> { +pub struct LuauLoadOptions { pub(crate) debug_name: String, - pub(crate) environment: Option>, + pub(crate) environment: Option, pub(crate) inject_globals: bool, pub(crate) codegen_enabled: bool, } -impl Default for LuauLoadOptions<'_> { +impl Default for LuauLoadOptions { fn default() -> Self { Self { debug_name: DEFAULT_DEBUG_NAME.to_string(), @@ -97,8 +97,8 @@ impl Default for LuauLoadOptions<'_> { } } -impl<'lua> FromLua<'lua> for LuauLoadOptions<'lua> { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for LuauLoadOptions { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { Ok(match value { LuaValue::Nil => Self::default(), LuaValue::Table(t) => { @@ -131,7 +131,7 @@ impl<'lua> FromLua<'lua> for LuauLoadOptions<'lua> { _ => { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "LoadOptions", + to: "LoadOptions".to_string(), message: Some(format!( "Invalid load options - expected string or table, got {}", value.type_name() diff --git a/crates/lune-std-net/Cargo.toml b/crates/lune-std-net/Cargo.toml index 373e59e..2aa7a88 100644 --- a/crates/lune-std-net/Cargo.toml +++ b/crates/lune-std-net/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } bstr = "1.9" diff --git a/crates/lune-std-net/src/client.rs b/crates/lune-std-net/src/client.rs index cae56bf..c796c93 100644 --- a/crates/lune-std-net/src/client.rs +++ b/crates/lune-std-net/src/client.rs @@ -119,7 +119,7 @@ impl NetClient { impl LuaUserData for NetClient {} -impl FromLua<'_> for NetClient { +impl FromLua for NetClient { fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::UserData(ud) = value { if let Ok(ctx) = ud.borrow::() { @@ -149,7 +149,7 @@ pub struct NetClientResponse { impl NetClientResponse { pub fn into_lua_table(self, lua: &Lua) -> LuaResult { - TableBuilder::new(lua)? + TableBuilder::new(lua.clone())? .with_value("ok", self.ok)? .with_value("statusCode", self.status_code)? .with_value("statusMessage", self.status_message)? diff --git a/crates/lune-std-net/src/config.rs b/crates/lune-std-net/src/config.rs index 6368d6d..bcd9cef 100644 --- a/crates/lune-std-net/src/config.rs +++ b/crates/lune-std-net/src/config.rs @@ -35,14 +35,14 @@ impl Default for RequestConfigOptions { } } -impl<'lua> FromLua<'lua> for RequestConfigOptions { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for RequestConfigOptions { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::Nil = value { // Nil means default options Ok(Self::default()) } else if let LuaValue::Table(tab) = value { // Table means custom options - let decompress = match tab.get::<_, Option>("decompress") { + let decompress = match tab.get::>("decompress") { Ok(decomp) => Ok(decomp.unwrap_or(true)), Err(_) => Err(LuaError::RuntimeError( "Invalid option value for 'decompress' in request config options".to_string(), @@ -53,7 +53,7 @@ impl<'lua> FromLua<'lua> for RequestConfigOptions { // Anything else is invalid Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "RequestConfigOptions", + to: "RequestConfigOptions".to_string(), message: Some(format!( "Invalid request config options - expected table or nil, got {}", value.type_name() @@ -73,7 +73,7 @@ pub struct RequestConfig { pub options: RequestConfigOptions, } -impl FromLua<'_> for RequestConfig { +impl FromLua for RequestConfig { fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult { // If we just got a string we assume its a GET request to a given url if let LuaValue::String(s) = value { @@ -88,27 +88,27 @@ impl FromLua<'_> for RequestConfig { } else if let LuaValue::Table(tab) = value { // If we got a table we are able to configure the entire request // Extract url - let url = match tab.get::<_, LuaString>("url") { + let url = match tab.get::("url") { Ok(config_url) => Ok(config_url.to_string_lossy().to_string()), Err(_) => Err(LuaError::runtime("Missing 'url' in request config")), }?; // Extract method - let method = match tab.get::<_, LuaString>("method") { + let method = match tab.get::("method") { Ok(config_method) => config_method.to_string_lossy().trim().to_ascii_uppercase(), Err(_) => "GET".to_string(), }; // Extract query - let query = match tab.get::<_, LuaTable>("query") { + let query = match tab.get::("query") { Ok(tab) => table_to_hash_map(tab, "query")?, Err(_) => HashMap::new(), }; // Extract headers - let headers = match tab.get::<_, LuaTable>("headers") { + let headers = match tab.get::("headers") { Ok(tab) => table_to_hash_map(tab, "headers")?, Err(_) => HashMap::new(), }; // Extract body - let body = match tab.get::<_, BString>("body") { + let body = match tab.get::("body") { Ok(config_body) => Some(config_body.as_bytes().to_owned()), Err(_) => None, }; @@ -129,7 +129,7 @@ impl FromLua<'_> for RequestConfig { ))), }?; // Parse any extra options given - let options = match tab.get::<_, LuaValue>("options") { + let options = match tab.get::("options") { Ok(opts) => RequestConfigOptions::from_lua(opts, lua)?, Err(_) => RequestConfigOptions::default(), }; @@ -146,7 +146,7 @@ impl FromLua<'_> for RequestConfig { // Anything else is invalid Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "RequestConfig", + to: "RequestConfig".to_string(), message: Some(format!( "Invalid request config - expected string or table, got {}", value.type_name() @@ -159,14 +159,14 @@ impl FromLua<'_> for RequestConfig { // Net serve config #[derive(Debug)] -pub struct ServeConfig<'a> { +pub struct ServeConfig { pub address: IpAddr, - pub handle_request: LuaFunction<'a>, - pub handle_web_socket: Option>, + pub handle_request: LuaFunction, + pub handle_web_socket: Option, } -impl<'lua> FromLua<'lua> for ServeConfig<'lua> { - fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult { +impl FromLua for ServeConfig { + fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult { if let LuaValue::Function(f) = &value { // Single function = request handler, rest is default Ok(ServeConfig { @@ -190,7 +190,7 @@ impl<'lua> FromLua<'lua> for ServeConfig<'lua> { .parse() .map_err(|_e| LuaError::FromLuaConversionError { from: value.type_name(), - to: "ServeConfig", + to: "ServeConfig".to_string(), message: Some(format!( "IP address format is incorrect - \ expected an IP in the form 'http://0.0.0.0' or '0.0.0.0', \ @@ -213,7 +213,7 @@ impl<'lua> FromLua<'lua> for ServeConfig<'lua> { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ServeConfig", + to: "ServeConfig".to_string(), message: Some(String::from( "Invalid serve config - expected table with 'handleRequest' or 'handleWebSocket' function", )), @@ -223,7 +223,7 @@ impl<'lua> FromLua<'lua> for ServeConfig<'lua> { // Anything else is invalid Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ServeConfig", + to: "ServeConfig".to_string(), message: None, }) } diff --git a/crates/lune-std-net/src/lib.rs b/crates/lune-std-net/src/lib.rs index 47db8f7..e17ff13 100644 --- a/crates/lune-std-net/src/lib.rs +++ b/crates/lune-std-net/src/lib.rs @@ -29,11 +29,11 @@ use lune_std_serde::{decode, encode, EncodeDecodeConfig, EncodeDecodeFormat}; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { NetClientBuilder::new() - .headers(&[("User-Agent", create_user_agent_header(lua)?)])? + .headers(&[("User-Agent", create_user_agent_header(&lua)?)])? .build()? - .into_registry(lua); + .into_registry(&lua); TableBuilder::new(lua)? .with_function("jsonEncode", net_json_encode)? .with_function("jsonDecode", net_json_decode)? @@ -45,10 +45,7 @@ pub fn module(lua: &Lua) -> LuaResult { .build_readonly() } -fn net_json_encode<'lua>( - lua: &'lua Lua, - (val, pretty): (LuaValue<'lua>, Option), -) -> LuaResult> { +fn net_json_encode(lua: &Lua, (val, pretty): (LuaValue, Option)) -> LuaResult { let config = EncodeDecodeConfig::from((EncodeDecodeFormat::Json, pretty.unwrap_or_default())); encode(val, lua, config) } @@ -58,44 +55,41 @@ fn net_json_decode(lua: &Lua, json: BString) -> LuaResult { decode(json, lua, config) } -async fn net_request(lua: &Lua, config: RequestConfig) -> LuaResult { - let client = NetClient::from_registry(lua); +async fn net_request(lua: Lua, config: RequestConfig) -> LuaResult { + let client = NetClient::from_registry(&lua); // NOTE: We spawn the request as a background task to free up resources in lua let res = lua.spawn(async move { client.request(config).await }); - res.await?.into_lua_table(lua) + res.await?.into_lua_table(&lua) } -async fn net_socket(lua: &Lua, url: String) -> LuaResult { +async fn net_socket(lua: Lua, url: String) -> LuaResult { let (ws, _) = tokio_tungstenite::connect_async(url).await.into_lua_err()?; - NetWebSocket::new(ws).into_lua(lua) + NetWebSocket::new(ws).into_lua(&lua) } -async fn net_serve<'lua>( - lua: &'lua Lua, - (port, config): (u16, ServeConfig<'lua>), -) -> LuaResult> { +async fn net_serve(lua: Lua, (port, config): (u16, ServeConfig)) -> LuaResult { serve(lua, port, config).await } -fn net_url_encode<'lua>( - lua: &'lua Lua, - (lua_string, as_binary): (LuaString<'lua>, Option), -) -> LuaResult> { +fn net_url_encode( + lua: &Lua, + (lua_string, as_binary): (LuaString, Option), +) -> LuaResult { if matches!(as_binary, Some(true)) { - urlencoding::encode_binary(lua_string.as_bytes()).into_lua(lua) + urlencoding::encode_binary(&lua_string.as_bytes()).into_lua(lua) } else { - urlencoding::encode(lua_string.to_str()?).into_lua(lua) + urlencoding::encode(&lua_string.to_str()?).into_lua(lua) } } -fn net_url_decode<'lua>( - lua: &'lua Lua, - (lua_string, as_binary): (LuaString<'lua>, Option), -) -> LuaResult> { +fn net_url_decode( + lua: &Lua, + (lua_string, as_binary): (LuaString, Option), +) -> LuaResult { if matches!(as_binary, Some(true)) { - urlencoding::decode_binary(lua_string.as_bytes()).into_lua(lua) + urlencoding::decode_binary(&lua_string.as_bytes()).into_lua(lua) } else { - urlencoding::decode(lua_string.to_str()?) + urlencoding::decode(&lua_string.to_str()?) .map_err(|e| LuaError::RuntimeError(format!("Encountered invalid encoding - {e}")))? .into_lua(lua) } diff --git a/crates/lune-std-net/src/server/keys.rs b/crates/lune-std-net/src/server/keys.rs index 9dac06a..aa34607 100644 --- a/crates/lune-std-net/src/server/keys.rs +++ b/crates/lune-std-net/src/server/keys.rs @@ -9,10 +9,10 @@ pub(super) struct SvcKeys { } impl SvcKeys { - pub(super) fn new<'lua>( - lua: &'lua Lua, - handle_request: LuaFunction<'lua>, - handle_websocket: Option>, + pub(super) fn new( + lua: Lua, + handle_request: LuaFunction, + handle_websocket: Option, ) -> LuaResult { static SERVE_COUNTER: AtomicUsize = AtomicUsize::new(0); let count = SERVE_COUNTER.fetch_add(1, Ordering::Relaxed); @@ -46,14 +46,11 @@ impl SvcKeys { self.key_websocket.is_some() } - pub(super) fn request_handler<'lua>(&self, lua: &'lua Lua) -> LuaResult> { + pub(super) fn request_handler(&self, lua: &Lua) -> LuaResult { lua.named_registry_value(self.key_request) } - pub(super) fn websocket_handler<'lua>( - &self, - lua: &'lua Lua, - ) -> LuaResult>> { + pub(super) fn websocket_handler(&self, lua: &Lua) -> LuaResult> { self.key_websocket .map(|key| lua.named_registry_value(key)) .transpose() diff --git a/crates/lune-std-net/src/server/mod.rs b/crates/lune-std-net/src/server/mod.rs index 7cfab9d..65783ec 100644 --- a/crates/lune-std-net/src/server/mod.rs +++ b/crates/lune-std-net/src/server/mod.rs @@ -1,7 +1,4 @@ -use std::{ - net::SocketAddr, - rc::{Rc, Weak}, -}; +use std::net::SocketAddr; use hyper::server::conn::http1; use hyper_util::rt::TokioIo; @@ -22,24 +19,14 @@ mod service; use keys::SvcKeys; use service::Svc; -pub async fn serve<'lua>( - lua: &'lua Lua, - port: u16, - config: ServeConfig<'lua>, -) -> LuaResult> { +pub async fn serve(lua: Lua, port: u16, config: ServeConfig) -> LuaResult { let addr: SocketAddr = (config.address, port).into(); let listener = TcpListener::bind(addr).await?; - let (lua_svc, lua_inner) = { - let rc = lua - .app_data_ref::>() - .expect("Missing weak lua ref") - .upgrade() - .expect("Lua was dropped unexpectedly"); - (Rc::clone(&rc), rc) - }; + let lua_svc = lua.clone(); + let lua_inner = lua.clone(); - let keys = SvcKeys::new(lua, config.handle_request, config.handle_web_socket)?; + let keys = SvcKeys::new(lua.clone(), config.handle_request, config.handle_web_socket)?; let svc = Svc { lua: lua_svc, addr, diff --git a/crates/lune-std-net/src/server/request.rs b/crates/lune-std-net/src/server/request.rs index e5eaf8d..d1df208 100644 --- a/crates/lune-std-net/src/server/request.rs +++ b/crates/lune-std-net/src/server/request.rs @@ -45,7 +45,7 @@ impl LuaRequest { }) .collect::>()?; - TableBuilder::new(lua)? + TableBuilder::new(lua.clone())? .with_value("method", method)? .with_value("path", path)? .with_value("query", query)? diff --git a/crates/lune-std-net/src/server/response.rs b/crates/lune-std-net/src/server/response.rs index 240a7cd..1240ef1 100644 --- a/crates/lune-std-net/src/server/response.rs +++ b/crates/lune-std-net/src/server/response.rs @@ -43,7 +43,7 @@ impl LuaResponse { } } -impl FromLua<'_> for LuaResponse { +impl FromLua for LuaResponse { fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { match value { // Plain strings from the handler are plaintext responses @@ -64,7 +64,7 @@ impl FromLua<'_> for LuaResponse { for pair in headers.pairs::() { let (h, v) = pair?; let name = HeaderName::from_str(&h).into_lua_err()?; - let value = HeaderValue::from_bytes(v.as_bytes()).into_lua_err()?; + let value = HeaderValue::from_bytes(&v.as_bytes()).into_lua_err()?; headers_map.insert(name, value); } } @@ -81,7 +81,7 @@ impl FromLua<'_> for LuaResponse { // Anything else is an error value => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "NetServeResponse", + to: "NetServeResponse".to_string(), message: None, }), } diff --git a/crates/lune-std-net/src/server/service.rs b/crates/lune-std-net/src/server/service.rs index 2787ca6..ec89572 100644 --- a/crates/lune-std-net/src/server/service.rs +++ b/crates/lune-std-net/src/server/service.rs @@ -1,4 +1,4 @@ -use std::{future::Future, net::SocketAddr, pin::Pin, rc::Rc}; +use std::{future::Future, net::SocketAddr, pin::Pin}; use http_body_util::{BodyExt, Full}; use hyper::{ @@ -17,7 +17,7 @@ use super::{ #[derive(Debug, Clone)] pub(super) struct Svc { - pub(super) lua: Rc, + pub(super) lua: Lua, pub(super) addr: SocketAddr, pub(super) keys: SvcKeys, } diff --git a/crates/lune-std-net/src/util.rs b/crates/lune-std-net/src/util.rs index ca79967..9fe01a0 100644 --- a/crates/lune-std-net/src/util.rs +++ b/crates/lune-std-net/src/util.rs @@ -10,7 +10,7 @@ use lune_utils::TableBuilder; pub fn create_user_agent_header(lua: &Lua) -> LuaResult { let version_global = lua .globals() - .get::<_, LuaString>("_VERSION") + .get::("_VERSION") .expect("Missing _VERSION global"); let version_global_str = version_global @@ -46,13 +46,13 @@ pub fn header_map_to_table( }); } - let mut builder = TableBuilder::new(lua)?; + let mut builder = TableBuilder::new(lua.clone())?; for (name, mut values) in res_headers { if values.len() == 1 { let value = values.pop().unwrap().into_lua(lua)?; builder = builder.with_value(name, value)?; } else { - let values = TableBuilder::new(lua)? + let values = TableBuilder::new(lua.clone())? .with_sequential_values(values)? .build_readonly()? .into_lua(lua)?; diff --git a/crates/lune-std-net/src/websocket.rs b/crates/lune-std-net/src/websocket.rs index 0225451..35ecae1 100644 --- a/crates/lune-std-net/src/websocket.rs +++ b/crates/lune-std-net/src/websocket.rs @@ -108,11 +108,11 @@ impl LuaUserData for NetWebSocket where T: AsyncRead + AsyncWrite + Unpin + 'static, { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_field_method_get("closeCode", |_, this| Ok(this.get_close_code())); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_async_method("close", |_, this, code: Option| async move { this.close(code).await }); diff --git a/crates/lune-std-process/Cargo.toml b/crates/lune-std-process/Cargo.toml index 86f5440..3b1e77a 100644 --- a/crates/lune-std-process/Cargo.toml +++ b/crates/lune-std-process/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } directories = "5.0" diff --git a/crates/lune-std-process/src/lib.rs b/crates/lune-std-process/src/lib.rs index 390f75d..30aa720 100644 --- a/crates/lune-std-process/src/lib.rs +++ b/crates/lune-std-process/src/lib.rs @@ -39,7 +39,7 @@ use lune_utils::path::get_current_dir; Errors when out of memory. */ #[allow(clippy::missing_panics_doc)] -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { let mut cwd_str = get_current_dir() .to_str() .expect("cwd should be valid UTF-8") @@ -60,13 +60,13 @@ pub fn module(lua: &Lua) -> LuaResult { .app_data_ref::>() .ok_or_else(|| LuaError::runtime("Missing args vec in Lua app data"))? .clone(); - let args_tab = TableBuilder::new(lua)? + let args_tab = TableBuilder::new(lua.clone())? .with_sequential_values(args_vec)? .build_readonly()?; // Create proxied table for env that gets & sets real env vars - let env_tab = TableBuilder::new(lua)? + let env_tab = TableBuilder::new(lua.clone())? .with_metatable( - TableBuilder::new(lua)? + TableBuilder::new(lua.clone())? .with_function(LuaMetaMethod::Index.name(), process_env_get)? .with_function(LuaMetaMethod::NewIndex.name(), process_env_set)? .with_function(LuaMetaMethod::Iter.name(), process_env_iter)? @@ -74,7 +74,7 @@ pub fn module(lua: &Lua) -> LuaResult { )? .build_readonly()?; // Create our process exit function, the scheduler crate provides this - let fns = Functions::new(lua)?; + let fns = Functions::new(lua.clone())?; let process_exit = fns.exit; // Create the full process table TableBuilder::new(lua)? @@ -90,10 +90,7 @@ pub fn module(lua: &Lua) -> LuaResult { .build_readonly() } -fn process_env_get<'lua>( - lua: &'lua Lua, - (_, key): (LuaValue<'lua>, String), -) -> LuaResult> { +fn process_env_get(lua: &Lua, (_, key): (LuaValue, String)) -> LuaResult { match env::var_os(key) { Some(value) => { let raw_value = RawOsString::new(value); @@ -105,10 +102,7 @@ fn process_env_get<'lua>( } } -fn process_env_set<'lua>( - _: &'lua Lua, - (_, key, value): (LuaValue<'lua>, String, Option), -) -> LuaResult<()> { +fn process_env_set(_: &Lua, (_, key, value): (LuaValue, String, Option)) -> LuaResult<()> { // Make sure key is valid, otherwise set_var will panic if key.is_empty() { Err(LuaError::RuntimeError("Key must not be empty".to_string())) @@ -136,10 +130,7 @@ fn process_env_set<'lua>( } } -fn process_env_iter<'lua>( - lua: &'lua Lua, - (_, ()): (LuaValue<'lua>, ()), -) -> LuaResult> { +fn process_env_iter(lua: &Lua, (_, ()): (LuaValue, ())) -> LuaResult { let mut vars = env::vars_os().collect::>().into_iter(); lua.create_function_mut(move |lua, (): ()| match vars.next() { Some((key, value)) => { @@ -155,7 +146,7 @@ fn process_env_iter<'lua>( } async fn process_exec( - lua: &Lua, + lua: Lua, (program, args, options): (String, Option>, ProcessSpawnOptions), ) -> LuaResult { let res = lua @@ -178,7 +169,7 @@ async fn process_exec( .unwrap_or(i32::from(!res.stderr.is_empty())); // Construct and return a readonly lua table with results - TableBuilder::new(lua)? + TableBuilder::new(lua.clone())? .with_value("ok", code == 0)? .with_value("code", code)? .with_value("stdout", lua.create_string(&res.stdout)?)? @@ -225,7 +216,7 @@ fn process_create( } }); - TableBuilder::new(lua)? + TableBuilder::new(lua.clone())? .with_value("stdout", ChildProcessReader(stdout))? .with_value("stderr", ChildProcessReader(stderr))? .with_value("stdin", ChildProcessWriter(stdin))? diff --git a/crates/lune-std-process/src/options/kind.rs b/crates/lune-std-process/src/options/kind.rs index 8eff17d..4af4c7f 100644 --- a/crates/lune-std-process/src/options/kind.rs +++ b/crates/lune-std-process/src/options/kind.rs @@ -62,14 +62,14 @@ impl FromStr for ProcessSpawnOptionsStdioKind { } } -impl<'lua> FromLua<'lua> for ProcessSpawnOptionsStdioKind { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for ProcessSpawnOptionsStdioKind { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { match value { LuaValue::Nil => Ok(Self::default()), LuaValue::String(s) => s.to_str()?.parse(), _ => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ProcessSpawnOptionsStdioKind", + to: "ProcessSpawnOptionsStdioKind".to_string(), message: Some(format!( "Invalid spawn options stdio kind - expected string, got {}", value.type_name() diff --git a/crates/lune-std-process/src/options/mod.rs b/crates/lune-std-process/src/options/mod.rs index be685bc..81fd804 100644 --- a/crates/lune-std-process/src/options/mod.rs +++ b/crates/lune-std-process/src/options/mod.rs @@ -22,8 +22,8 @@ pub(super) struct ProcessSpawnOptions { pub stdio: ProcessSpawnOptionsStdio, } -impl<'lua> FromLua<'lua> for ProcessSpawnOptions { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for ProcessSpawnOptions { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { let mut this = Self::default(); let value = match value { LuaValue::Nil => return Ok(this), @@ -31,7 +31,7 @@ impl<'lua> FromLua<'lua> for ProcessSpawnOptions { _ => { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ProcessSpawnOptions", + to: "ProcessSpawnOptions".to_string(), message: Some(format!( "Invalid spawn options - expected table, got {}", value.type_name() @@ -49,7 +49,7 @@ impl<'lua> FromLua<'lua> for ProcessSpawnOptions { match value.get("cwd")? { LuaValue::Nil => {} LuaValue::String(s) => { - let mut cwd = PathBuf::from(s.to_str()?); + let mut cwd = PathBuf::from(s.to_str()?.to_string()); if let Ok(stripped) = cwd.strip_prefix("~") { let user_dirs = UserDirs::new().ok_or_else(|| { LuaError::runtime( diff --git a/crates/lune-std-process/src/options/stdio.rs b/crates/lune-std-process/src/options/stdio.rs index 4c12ff4..58c2c87 100644 --- a/crates/lune-std-process/src/options/stdio.rs +++ b/crates/lune-std-process/src/options/stdio.rs @@ -19,8 +19,8 @@ impl From for ProcessSpawnOptionsStdio { } } -impl<'lua> FromLua<'lua> for ProcessSpawnOptionsStdio { - fn from_lua(value: LuaValue<'lua>, lua: &'lua Lua) -> LuaResult { +impl FromLua for ProcessSpawnOptionsStdio { + fn from_lua(value: LuaValue, lua: &Lua) -> LuaResult { match value { LuaValue::Nil => Ok(Self::default()), LuaValue::String(s) => { @@ -45,7 +45,7 @@ impl<'lua> FromLua<'lua> for ProcessSpawnOptionsStdio { } _ => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ProcessSpawnOptionsStdio", + to: "ProcessSpawnOptionsStdio".to_string(), message: Some(format!( "Invalid spawn options stdio - expected string or table, got {}", value.type_name() diff --git a/crates/lune-std-process/src/stream.rs b/crates/lune-std-process/src/stream.rs index 830e055..3fd2347 100644 --- a/crates/lune-std-process/src/stream.rs +++ b/crates/lune-std-process/src/stream.rs @@ -27,18 +27,21 @@ impl ChildProcessReader { } impl LuaUserData for ChildProcessReader { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { - methods.add_async_method_mut("read", |lua, this, chunk_size: Option| async move { - let buf = this.read(chunk_size).await?; + fn add_methods>(methods: &mut M) { + methods.add_async_method_mut( + "read", + |lua, mut this, chunk_size: Option| async move { + let buf = this.read(chunk_size).await?; - if buf.is_empty() { - return Ok(LuaValue::Nil); - } + if buf.is_empty() { + return Ok(LuaValue::Nil); + } - Ok(LuaValue::String(lua.create_string(buf)?)) - }); + Ok(LuaValue::String(lua.create_string(buf)?)) + }, + ); - methods.add_async_method_mut("readToEnd", |lua, this, ()| async { + methods.add_async_method_mut("readToEnd", |lua, mut this, ()| async move { Ok(lua.create_string(this.read_to_end().await?)) }); } @@ -52,7 +55,9 @@ impl ChildProcessWriter { } impl LuaUserData for ChildProcessWriter { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { - methods.add_async_method_mut("write", |_, this, data| async { this.write(data).await }); + fn add_methods>(methods: &mut M) { + methods.add_async_method_mut("write", |_, mut this, data| async move { + this.write(data).await + }); } } diff --git a/crates/lune-std-regex/Cargo.toml b/crates/lune-std-regex/Cargo.toml index 5e1fe73..9209718 100644 --- a/crates/lune-std-regex/Cargo.toml +++ b/crates/lune-std-regex/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } regex = "1.10" self_cell = "1.0" diff --git a/crates/lune-std-regex/src/captures.rs b/crates/lune-std-regex/src/captures.rs index fcfde93..e74e05c 100644 --- a/crates/lune-std-regex/src/captures.rs +++ b/crates/lune-std-regex/src/captures.rs @@ -58,7 +58,7 @@ impl LuaCaptures { } impl LuaUserData for LuaCaptures { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_method("get", |_, this, index: usize| { Ok(this .captures() @@ -85,7 +85,7 @@ impl LuaUserData for LuaCaptures { }); } - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_meta_field(LuaMetaMethod::Type, "RegexCaptures"); } } diff --git a/crates/lune-std-regex/src/lib.rs b/crates/lune-std-regex/src/lib.rs index 97fb279..9697e37 100644 --- a/crates/lune-std-regex/src/lib.rs +++ b/crates/lune-std-regex/src/lib.rs @@ -17,7 +17,7 @@ use self::regex::LuaRegex; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_function("new", new_regex)? .build_readonly() diff --git a/crates/lune-std-regex/src/matches.rs b/crates/lune-std-regex/src/matches.rs index ad21491..ecba5b5 100644 --- a/crates/lune-std-regex/src/matches.rs +++ b/crates/lune-std-regex/src/matches.rs @@ -34,7 +34,7 @@ impl LuaMatch { } impl LuaUserData for LuaMatch { - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { // NOTE: Strings are 0 based in Rust but 1 based in Luau, and end of range in Rust is exclusive fields.add_field_method_get("start", |_, this| Ok(this.start.saturating_add(1))); fields.add_field_method_get("finish", |_, this| Ok(this.end)); @@ -44,7 +44,7 @@ impl LuaUserData for LuaMatch { fields.add_meta_field(LuaMetaMethod::Type, "RegexMatch"); } - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_meta_method(LuaMetaMethod::Len, |_, this, ()| Ok(this.range().len())); methods.add_meta_method(LuaMetaMethod::ToString, |_, this, ()| { Ok(this.slice().to_string()) diff --git a/crates/lune-std-regex/src/regex.rs b/crates/lune-std-regex/src/regex.rs index 2ae26d9..44cbca4 100644 --- a/crates/lune-std-regex/src/regex.rs +++ b/crates/lune-std-regex/src/regex.rs @@ -25,7 +25,7 @@ impl LuaRegex { } impl LuaUserData for LuaRegex { - fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) { + fn add_methods>(methods: &mut M) { methods.add_method("isMatch", |_, this, text: String| { Ok(this.inner.is_match(&text)) }); @@ -70,7 +70,7 @@ impl LuaUserData for LuaRegex { }); } - fn add_fields<'lua, F: LuaUserDataFields<'lua, Self>>(fields: &mut F) { + fn add_fields>(fields: &mut F) { fields.add_meta_field(LuaMetaMethod::Type, "Regex"); } } diff --git a/crates/lune-std-roblox/Cargo.toml b/crates/lune-std-roblox/Cargo.toml index d928cc8..e00f83c 100644 --- a/crates/lune-std-roblox/Cargo.toml +++ b/crates/lune-std-roblox/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } rbx_cookie = { version = "0.1.4", default-features = false } diff --git a/crates/lune-std-roblox/src/lib.rs b/crates/lune-std-roblox/src/lib.rs index 65339ee..829905e 100644 --- a/crates/lune-std-roblox/src/lib.rs +++ b/crates/lune-std-roblox/src/lib.rs @@ -23,10 +23,10 @@ use roblox_install::RobloxStudio; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { let mut roblox_constants = Vec::new(); - let roblox_module = lune_roblox::module(lua)?; + let roblox_module = lune_roblox::module(lua.clone())?; for pair in roblox_module.pairs::() { roblox_constants.push(pair?); } @@ -48,36 +48,30 @@ pub fn module(lua: &Lua) -> LuaResult { .build_readonly() } -async fn deserialize_place<'lua>( - lua: &'lua Lua, - contents: LuaString<'lua>, -) -> LuaResult> { +async fn deserialize_place(lua: Lua, contents: LuaString) -> LuaResult { let bytes = contents.as_bytes().to_vec(); let fut = lua.spawn_blocking(move || { let doc = Document::from_bytes(bytes, DocumentKind::Place)?; let data_model = doc.into_data_model_instance()?; Ok::<_, DocumentError>(data_model) }); - fut.await.into_lua_err()?.into_lua(lua) + fut.await.into_lua_err()?.into_lua(&lua) } -async fn deserialize_model<'lua>( - lua: &'lua Lua, - contents: LuaString<'lua>, -) -> LuaResult> { +async fn deserialize_model(lua: Lua, contents: LuaString) -> LuaResult { let bytes = contents.as_bytes().to_vec(); let fut = lua.spawn_blocking(move || { let doc = Document::from_bytes(bytes, DocumentKind::Model)?; let instance_array = doc.into_instance_array()?; Ok::<_, DocumentError>(instance_array) }); - fut.await.into_lua_err()?.into_lua(lua) + fut.await.into_lua_err()?.into_lua(&lua) } -async fn serialize_place<'lua>( - lua: &'lua Lua, - (data_model, as_xml): (LuaUserDataRef<'lua, Instance>, Option), -) -> LuaResult> { +async fn serialize_place( + lua: Lua, + (data_model, as_xml): (LuaUserDataRef, Option), +) -> LuaResult { let data_model = *data_model; let fut = lua.spawn_blocking(move || { let doc = Document::from_data_model_instance(data_model)?; @@ -91,10 +85,10 @@ async fn serialize_place<'lua>( lua.create_string(bytes) } -async fn serialize_model<'lua>( - lua: &'lua Lua, - (instances, as_xml): (Vec>, Option), -) -> LuaResult> { +async fn serialize_model( + lua: Lua, + (instances, as_xml): (Vec>, Option), +) -> LuaResult { let instances = instances.iter().map(|i| **i).collect(); let fut = lua.spawn_blocking(move || { let doc = Document::from_instance_array(instances)?; diff --git a/crates/lune-std-serde/Cargo.toml b/crates/lune-std-serde/Cargo.toml index da892f5..d0cde53 100644 --- a/crates/lune-std-serde/Cargo.toml +++ b/crates/lune-std-serde/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau", "serialize"] } +mlua = { version = "0.10.3", features = ["luau", "serialize"] } async-compression = { version = "0.4", features = [ "tokio", diff --git a/crates/lune-std-serde/src/compress_decompress.rs b/crates/lune-std-serde/src/compress_decompress.rs index b0f560a..9d80178 100644 --- a/crates/lune-std-serde/src/compress_decompress.rs +++ b/crates/lune-std-serde/src/compress_decompress.rs @@ -84,8 +84,8 @@ impl CompressDecompressFormat { } } -impl<'lua> FromLua<'lua> for CompressDecompressFormat { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for CompressDecompressFormat { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::String(s) = &value { match s.to_string_lossy().to_ascii_lowercase().trim() { "brotli" => Ok(Self::Brotli), @@ -94,7 +94,7 @@ impl<'lua> FromLua<'lua> for CompressDecompressFormat { "zlib" => Ok(Self::ZLib), kind => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "CompressDecompressFormat", + to: "CompressDecompressFormat".to_string(), message: Some(format!( "Invalid format '{kind}', valid formats are: brotli, gzip, lz4, zlib" )), @@ -103,7 +103,7 @@ impl<'lua> FromLua<'lua> for CompressDecompressFormat { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "CompressDecompressFormat", + to: "CompressDecompressFormat".to_string(), message: None, }) } diff --git a/crates/lune-std-serde/src/encode_decode.rs b/crates/lune-std-serde/src/encode_decode.rs index 80e1a5f..8d46920 100644 --- a/crates/lune-std-serde/src/encode_decode.rs +++ b/crates/lune-std-serde/src/encode_decode.rs @@ -28,8 +28,8 @@ pub enum EncodeDecodeFormat { Toml, } -impl<'lua> FromLua<'lua> for EncodeDecodeFormat { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for EncodeDecodeFormat { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::String(s) = &value { match s.to_string_lossy().to_ascii_lowercase().trim() { "json" => Ok(Self::Json), @@ -37,7 +37,7 @@ impl<'lua> FromLua<'lua> for EncodeDecodeFormat { "toml" => Ok(Self::Toml), kind => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "EncodeDecodeFormat", + to: "EncodeDecodeFormat".to_string(), message: Some(format!( "Invalid format '{kind}', valid formats are: json, yaml, toml" )), @@ -46,7 +46,7 @@ impl<'lua> FromLua<'lua> for EncodeDecodeFormat { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "EncodeDecodeFormat", + to: "EncodeDecodeFormat".to_string(), message: None, }) } @@ -89,11 +89,7 @@ impl From<(EncodeDecodeFormat, bool)> for EncodeDecodeConfig { Errors when the encoding fails. */ -pub fn encode<'lua>( - value: LuaValue<'lua>, - lua: &'lua Lua, - config: EncodeDecodeConfig, -) -> LuaResult> { +pub fn encode(value: LuaValue, lua: &Lua, config: EncodeDecodeConfig) -> LuaResult { let bytes = match config.format { EncodeDecodeFormat::Json => { let serialized: JsonValue = lua.from_value_with(value, LUA_DESERIALIZE_OPTIONS)?; diff --git a/crates/lune-std-serde/src/hash.rs b/crates/lune-std-serde/src/hash.rs index 251976e..7ae5e6d 100644 --- a/crates/lune-std-serde/src/hash.rs +++ b/crates/lune-std-serde/src/hash.rs @@ -120,7 +120,7 @@ impl HashOptions { .secret .ok_or_else(|| LuaError::FromLuaConversionError { from: "nil", - to: "string or buffer", + to: "string or buffer".to_string(), message: Some("Argument #3 missing or nil".to_string()), })?; @@ -174,8 +174,8 @@ impl HashOptions { } } -impl<'lua> FromLua<'lua> for HashAlgorithm { - fn from_lua(value: LuaValue<'lua>, _lua: &'lua Lua) -> LuaResult { +impl FromLua for HashAlgorithm { + fn from_lua(value: LuaValue, _lua: &Lua) -> LuaResult { if let LuaValue::String(str) = value { /* Casing tends to vary for algorithms, so rather than force @@ -200,7 +200,7 @@ impl<'lua> FromLua<'lua> for HashAlgorithm { _ => Err(LuaError::FromLuaConversionError { from: "string", - to: "HashAlgorithm", + to: "HashAlgorithm".to_string(), message: Some(format!( "Invalid hashing algorithm '{str}', valid kinds are:\n{}", HashAlgorithm::ALL @@ -214,22 +214,22 @@ impl<'lua> FromLua<'lua> for HashAlgorithm { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "HashAlgorithm", + to: "HashAlgorithm".to_string(), message: None, }) } } } -impl<'lua> FromLuaMulti<'lua> for HashOptions { - fn from_lua_multi(mut values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult { +impl FromLuaMulti for HashOptions { + fn from_lua_multi(mut values: LuaMultiValue, lua: &Lua) -> LuaResult { let algorithm = values .pop_front() .map(|value| HashAlgorithm::from_lua(value, lua)) .transpose()? .ok_or_else(|| LuaError::FromLuaConversionError { from: "nil", - to: "HashAlgorithm", + to: "HashOptions".to_string(), message: Some("Argument #1 missing or nil".to_string()), })?; let message = values @@ -238,7 +238,7 @@ impl<'lua> FromLuaMulti<'lua> for HashOptions { .transpose()? .ok_or_else(|| LuaError::FromLuaConversionError { from: "nil", - to: "string or buffer", + to: "string or buffer".to_string(), message: Some("Argument #2 missing or nil".to_string()), })?; let secret = values diff --git a/crates/lune-std-serde/src/lib.rs b/crates/lune-std-serde/src/lib.rs index 26ee26a..4f02dda 100644 --- a/crates/lune-std-serde/src/lib.rs +++ b/crates/lune-std-serde/src/lib.rs @@ -20,7 +20,7 @@ pub use self::hash::HashOptions; Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_function("encode", serde_encode)? .with_function("decode", serde_decode)? @@ -31,10 +31,10 @@ pub fn module(lua: &Lua) -> LuaResult { .build_readonly() } -fn serde_encode<'lua>( - lua: &'lua Lua, - (format, value, pretty): (EncodeDecodeFormat, LuaValue<'lua>, Option), -) -> LuaResult> { +fn serde_encode( + lua: &Lua, + (format, value, pretty): (EncodeDecodeFormat, LuaValue, Option), +) -> LuaResult { let config = EncodeDecodeConfig::from((format, pretty.unwrap_or_default())); encode(value, lua, config) } @@ -45,7 +45,7 @@ fn serde_decode(lua: &Lua, (format, bs): (EncodeDecodeFormat, BString)) -> LuaRe } async fn serde_compress( - lua: &Lua, + lua: Lua, (format, bs, level): (CompressDecompressFormat, BString, Option), ) -> LuaResult { let bytes = compress(bs, format, level).await?; @@ -53,7 +53,7 @@ async fn serde_compress( } async fn serde_decompress( - lua: &Lua, + lua: Lua, (format, bs): (CompressDecompressFormat, BString), ) -> LuaResult { let bytes = decompress(bs, format).await?; diff --git a/crates/lune-std-stdio/Cargo.toml b/crates/lune-std-stdio/Cargo.toml index ca296d7..927fdaf 100644 --- a/crates/lune-std-stdio/Cargo.toml +++ b/crates/lune-std-stdio/Cargo.toml @@ -14,7 +14,7 @@ workspace = true [dependencies] dialoguer = "0.11" -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau", "error-send"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } tokio = { version = "1", default-features = false, features = [ diff --git a/crates/lune-std-stdio/src/lib.rs b/crates/lune-std-stdio/src/lib.rs index a4f7751..48a78ec 100644 --- a/crates/lune-std-stdio/src/lib.rs +++ b/crates/lune-std-stdio/src/lib.rs @@ -25,7 +25,7 @@ const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new() Errors when out of memory. */ -pub fn module(lua: &Lua) -> LuaResult { +pub fn module(lua: Lua) -> LuaResult { TableBuilder::new(lua)? .with_function("color", stdio_color)? .with_function("style", stdio_style)? @@ -49,16 +49,16 @@ fn stdio_format(_: &Lua, args: LuaMultiValue) -> LuaResult { Ok(pretty_format_multi_value(&args, &FORMAT_CONFIG)) } -async fn stdio_write(_: &Lua, s: LuaString<'_>) -> LuaResult<()> { +async fn stdio_write(_: Lua, s: LuaString) -> LuaResult<()> { let mut stdout = stdout(); - stdout.write_all(s.as_bytes()).await?; + stdout.write_all(&s.as_bytes()).await?; stdout.flush().await?; Ok(()) } -async fn stdio_ewrite(_: &Lua, s: LuaString<'_>) -> LuaResult<()> { +async fn stdio_ewrite(_: Lua, s: LuaString) -> LuaResult<()> { let mut stderr = stderr(); - stderr.write_all(s.as_bytes()).await?; + stderr.write_all(&s.as_bytes()).await?; stderr.flush().await?; Ok(()) } @@ -71,14 +71,14 @@ async fn stdio_ewrite(_: &Lua, s: LuaString<'_>) -> LuaResult<()> { having that capture the first two lines and then read the rest of the input. */ -async fn stdio_read_to_end(lua: &Lua, (): ()) -> LuaResult { +async fn stdio_read_to_end(lua: Lua, (): ()) -> LuaResult { let mut input = Vec::new(); let mut stdin = stdin(); stdin.read_to_end(&mut input).await?; lua.create_string(&input) } -async fn stdio_prompt(lua: &Lua, options: PromptOptions) -> LuaResult { +async fn stdio_prompt(lua: Lua, options: PromptOptions) -> LuaResult { lua.spawn_blocking(move || prompt(options)) .await .into_lua_err() diff --git a/crates/lune-std-stdio/src/prompt.rs b/crates/lune-std-stdio/src/prompt.rs index 8a72510..605b1c2 100644 --- a/crates/lune-std-stdio/src/prompt.rs +++ b/crates/lune-std-stdio/src/prompt.rs @@ -49,15 +49,15 @@ impl fmt::Display for PromptKind { } } -impl<'lua> FromLua<'lua> for PromptKind { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for PromptKind { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::Nil = value { Ok(Self::default()) } else if let LuaValue::String(s) = value { let s = s.to_str()?; s.parse().map_err(|()| LuaError::FromLuaConversionError { from: "string", - to: "PromptKind", + to: "PromptKind".to_string(), message: Some(format!( "Invalid prompt kind '{s}', valid kinds are:\n{}", PromptKind::ALL @@ -70,7 +70,7 @@ impl<'lua> FromLua<'lua> for PromptKind { } else { Err(LuaError::FromLuaConversionError { from: "nil", - to: "PromptKind", + to: "PromptKind".to_string(), message: None, }) } @@ -85,8 +85,8 @@ pub struct PromptOptions { pub options: Option>, } -impl<'lua> FromLuaMulti<'lua> for PromptOptions { - fn from_lua_multi(mut values: LuaMultiValue<'lua>, lua: &'lua Lua) -> LuaResult { +impl FromLuaMulti for PromptOptions { + fn from_lua_multi(mut values: LuaMultiValue, lua: &Lua) -> LuaResult { // Argument #1 - prompt kind (optional) let kind = values .pop_front() @@ -118,7 +118,7 @@ impl<'lua> FromLuaMulti<'lua> for PromptOptions { value => { return Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "PromptOptions", + to: "PromptOptions".to_string(), message: Some("Argument #3 must be a boolean, table, or nil".to_string()), }) } @@ -133,14 +133,14 @@ impl<'lua> FromLuaMulti<'lua> for PromptOptions { if matches!(kind, PromptKind::Confirm) && text.is_none() { return Err(LuaError::FromLuaConversionError { from: "nil", - to: "PromptOptions", + to: "PromptOptions".to_string(), message: Some("Argument #2 missing or nil".to_string()), }); } if matches!(kind, PromptKind::Select | PromptKind::MultiSelect) && options.is_none() { return Err(LuaError::FromLuaConversionError { from: "nil", - to: "PromptOptions", + to: "PromptOptions".to_string(), message: Some("Argument #3 missing or nil".to_string()), }); } @@ -164,8 +164,8 @@ pub enum PromptResult { None, } -impl<'lua> IntoLua<'lua> for PromptResult { - fn into_lua(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLua for PromptResult { + fn into_lua(self, lua: &Lua) -> LuaResult { Ok(match self { Self::String(s) => LuaValue::String(lua.create_string(&s)?), Self::Boolean(b) => LuaValue::Boolean(b), diff --git a/crates/lune-std-stdio/src/style_and_color.rs b/crates/lune-std-stdio/src/style_and_color.rs index 4080118..ec1b3ef 100644 --- a/crates/lune-std-stdio/src/style_and_color.rs +++ b/crates/lune-std-stdio/src/style_and_color.rs @@ -88,7 +88,7 @@ impl FromStr for ColorKind { } } -impl FromLua<'_> for ColorKind { +impl FromLua for ColorKind { fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::String(s) = value { let s = s.to_str()?; @@ -96,7 +96,7 @@ impl FromLua<'_> for ColorKind { Ok(color) => Ok(color), Err(()) => Err(LuaError::FromLuaConversionError { from: "string", - to: "ColorKind", + to: "ColorKind".to_string(), message: Some(format!( "Invalid color kind '{s}'\nValid kinds are: {}", Self::ALL @@ -110,7 +110,7 @@ impl FromLua<'_> for ColorKind { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "ColorKind", + to: "ColorKind".to_string(), message: None, }) } @@ -165,7 +165,7 @@ impl FromStr for StyleKind { } } -impl FromLua<'_> for StyleKind { +impl FromLua for StyleKind { fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { if let LuaValue::String(s) = value { let s = s.to_str()?; @@ -173,7 +173,7 @@ impl FromLua<'_> for StyleKind { Ok(style) => Ok(style), Err(()) => Err(LuaError::FromLuaConversionError { from: "string", - to: "StyleKind", + to: "StyleKind".to_string(), message: Some(format!( "Invalid style kind '{s}'\nValid kinds are: {}", Self::ALL @@ -187,7 +187,7 @@ impl FromLua<'_> for StyleKind { } else { Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "StyleKind", + to: "StyleKind".to_string(), message: None, }) } diff --git a/crates/lune-std-task/Cargo.toml b/crates/lune-std-task/Cargo.toml index 2a62e1f..b6be857 100644 --- a/crates/lune-std-task/Cargo.toml +++ b/crates/lune-std-task/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } tokio = { version = "1", default-features = false, features = ["time"] } diff --git a/crates/lune-std-task/src/lib.rs b/crates/lune-std-task/src/lib.rs index dce0873..aa8baaa 100644 --- a/crates/lune-std-task/src/lib.rs +++ b/crates/lune-std-task/src/lib.rs @@ -16,13 +16,13 @@ use lune_utils::TableBuilder; Errors when out of memory, or if default Lua globals are missing. */ -pub fn module(lua: &Lua) -> LuaResult { - let fns = Functions::new(lua)?; +pub fn module(lua: Lua) -> LuaResult { + let fns = Functions::new(lua.clone())?; // Create wait & delay functions let task_wait = lua.create_async_function(wait)?; - let task_delay_env = TableBuilder::new(lua)? - .with_value("select", lua.globals().get::<_, LuaFunction>("select")?)? + let task_delay_env = TableBuilder::new(lua.clone())? + .with_value("select", lua.globals().get::("select")?)? .with_value("spawn", fns.spawn.clone())? .with_value("defer", fns.defer.clone())? .with_value("wait", task_wait.clone())? @@ -49,7 +49,7 @@ return defer(function(...) end, ...) "; -async fn wait(_: &Lua, secs: Option) -> LuaResult { +async fn wait(_: Lua, secs: Option) -> LuaResult { let duration = Duration::from_secs_f64(secs.unwrap_or_default()); let before = Instant::now(); diff --git a/crates/lune-std/Cargo.toml b/crates/lune-std/Cargo.toml index 07762b6..fd1e803 100644 --- a/crates/lune-std/Cargo.toml +++ b/crates/lune-std/Cargo.toml @@ -38,7 +38,7 @@ stdio = ["dep:lune-std-stdio"] task = ["dep:lune-std-task"] [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } serde = { version = "1.0", features = ["derive"] } diff --git a/crates/lune-std/src/global.rs b/crates/lune-std/src/global.rs index 1c0944f..c0a1fa1 100644 --- a/crates/lune-std/src/global.rs +++ b/crates/lune-std/src/global.rs @@ -49,7 +49,7 @@ impl LuneStandardGlobal { */ #[rustfmt::skip] #[allow(unreachable_patterns)] - pub fn create<'lua>(&self, lua: &'lua Lua) -> LuaResult> { + pub fn create(&self, lua: Lua) -> LuaResult { let res = match self { Self::GTable => crate::globals::g_table::create(lua), Self::Print => crate::globals::print::create(lua), diff --git a/crates/lune-std/src/globals/g_table.rs b/crates/lune-std/src/globals/g_table.rs index e21fa1e..31ed6b6 100644 --- a/crates/lune-std/src/globals/g_table.rs +++ b/crates/lune-std/src/globals/g_table.rs @@ -1,5 +1,5 @@ use mlua::prelude::*; -pub fn create(lua: &Lua) -> LuaResult { - lua.create_table()?.into_lua(lua) +pub fn create(lua: Lua) -> LuaResult { + lua.create_table()?.into_lua(&lua) } diff --git a/crates/lune-std/src/globals/print.rs b/crates/lune-std/src/globals/print.rs index 3b8d5f1..7eab27c 100644 --- a/crates/lune-std/src/globals/print.rs +++ b/crates/lune-std/src/globals/print.rs @@ -7,13 +7,13 @@ const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new() .with_max_depth(4) .with_colors_enabled(true); -pub fn create(lua: &Lua) -> LuaResult { - let f = lua.create_function(|_, args: LuaMultiValue| { +pub fn create(lua: Lua) -> LuaResult { + let f = lua.create_function(|_: &Lua, args: LuaMultiValue| { let formatted = format!("{}\n", pretty_format_multi_value(&args, &FORMAT_CONFIG)); let mut stdout = std::io::stdout(); stdout.write_all(formatted.as_bytes())?; stdout.flush()?; Ok(()) })?; - f.into_lua(lua) + f.into_lua(&lua) } diff --git a/crates/lune-std/src/globals/require/alias.rs b/crates/lune-std/src/globals/require/alias.rs index 924056b..647623b 100644 --- a/crates/lune-std/src/globals/require/alias.rs +++ b/crates/lune-std/src/globals/require/alias.rs @@ -6,16 +6,13 @@ use crate::luaurc::LuauRc; use super::context::*; -pub(super) async fn require<'lua, 'ctx>( - lua: &'lua Lua, - ctx: &'ctx RequireContext, +pub(super) async fn require( + lua: Lua, + ctx: &RequireContext, source: &str, alias: &str, path: &str, -) -> LuaResult> -where - 'lua: 'ctx, -{ +) -> LuaResult { let alias = alias.to_ascii_lowercase(); let parent = clean_path_and_make_absolute(source) diff --git a/crates/lune-std/src/globals/require/context.rs b/crates/lune-std/src/globals/require/context.rs index b919a40..5759315 100644 --- a/crates/lune-std/src/globals/require/context.rs +++ b/crates/lune-std/src/globals/require/context.rs @@ -100,11 +100,7 @@ impl RequireContext { Will panic if the path has not been cached, use [`is_cached`] first. */ - pub fn get_from_cache<'lua>( - &self, - lua: &'lua Lua, - abs_path: impl AsRef, - ) -> LuaResult> { + pub fn get_from_cache(&self, lua: Lua, abs_path: impl AsRef) -> LuaResult { let results = self .results .try_lock() @@ -129,11 +125,11 @@ impl RequireContext { Will panic if the path has not been cached, use [`is_cached`] first. */ - pub async fn wait_for_cache<'lua>( + pub async fn wait_for_cache( &self, - lua: &'lua Lua, + lua: Lua, abs_path: impl AsRef, - ) -> LuaResult> { + ) -> LuaResult { let mut thread_recv = { let pending = self .pending @@ -152,7 +148,7 @@ impl RequireContext { async fn load( &self, - lua: &Lua, + lua: Lua, abs_path: impl AsRef, rel_path: impl AsRef, ) -> LuaResult { @@ -188,12 +184,12 @@ impl RequireContext { /** Loads (requires) the file at the given path. */ - pub async fn load_with_caching<'lua>( + pub async fn load_with_caching( &self, - lua: &'lua Lua, + lua: Lua, abs_path: impl AsRef, rel_path: impl AsRef, - ) -> LuaResult> { + ) -> LuaResult { let abs_path = abs_path.as_ref(); let rel_path = rel_path.as_ref(); @@ -205,7 +201,7 @@ impl RequireContext { .insert(abs_path.to_path_buf(), broadcast_tx); // Try to load at this abs path - let load_res = self.load(lua, abs_path, rel_path).await; + let load_res = self.load(lua.clone(), abs_path, rel_path).await; let load_val = match &load_res { Err(e) => Err(e.clone()), Ok(k) => { @@ -241,11 +237,7 @@ impl RequireContext { /** Loads (requires) the library with the given name. */ - pub fn load_library<'lua>( - &self, - lua: &'lua Lua, - name: impl AsRef, - ) -> LuaResult> { + pub fn load_library(&self, lua: Lua, name: impl AsRef) -> LuaResult { let library: LuneStandardLibrary = match name.as_ref().parse() { Err(e) => return Err(LuaError::runtime(e)), Ok(b) => b, @@ -268,7 +260,7 @@ impl RequireContext { }; } - let result = library.module(lua); + let result = library.module(lua.clone()); cache.insert( library, diff --git a/crates/lune-std/src/globals/require/library.rs b/crates/lune-std/src/globals/require/library.rs index b47ea92..2a2d1b7 100644 --- a/crates/lune-std/src/globals/require/library.rs +++ b/crates/lune-std/src/globals/require/library.rs @@ -2,13 +2,6 @@ use mlua::prelude::*; use super::context::*; -pub(super) fn require<'lua, 'ctx>( - lua: &'lua Lua, - ctx: &'ctx RequireContext, - name: &str, -) -> LuaResult> -where - 'lua: 'ctx, -{ +pub(super) fn require(lua: Lua, ctx: &RequireContext, name: &str) -> LuaResult { ctx.load_library(lua, name) } diff --git a/crates/lune-std/src/globals/require/mod.rs b/crates/lune-std/src/globals/require/mod.rs index 3876e36..87c57e5 100644 --- a/crates/lune-std/src/globals/require/mod.rs +++ b/crates/lune-std/src/globals/require/mod.rs @@ -13,7 +13,7 @@ const REQUIRE_IMPL: &str = r" return require(source(), ...) "; -pub fn create(lua: &Lua) -> LuaResult { +pub fn create(lua: Lua) -> LuaResult { lua.set_app_data(RequireContext::new()); /* @@ -48,7 +48,7 @@ pub fn create(lua: &Lua) -> LuaResult { }, })?; - let require_env = TableBuilder::new(lua)? + let require_env = TableBuilder::new(lua.clone())? .with_value("source", get_source_fn)? .with_value("require", require_fn)? .build_readonly()?; @@ -57,13 +57,10 @@ pub fn create(lua: &Lua) -> LuaResult { .set_name("require") .set_environment(require_env) .into_function()? - .into_lua(lua) + .into_lua(&lua) } -async fn require<'lua>( - lua: &'lua Lua, - (source, path): (LuaString<'lua>, LuaString<'lua>), -) -> LuaResult> { +async fn require(lua: Lua, (source, path): (LuaString, LuaString)) -> LuaResult { let source = source .to_str() .into_lua_err() @@ -77,8 +74,9 @@ async fn require<'lua>( .to_string(); let context = lua - .app_data_ref() - .expect("Failed to get RequireContext from app data"); + .app_data_ref::() + .expect("Failed to get RequireContext from app data") + .clone(); if let Some(builtin_name) = path.strip_prefix("@lune/").map(str::to_ascii_lowercase) { library::require(lua, &context, &builtin_name) diff --git a/crates/lune-std/src/globals/require/path.rs b/crates/lune-std/src/globals/require/path.rs index 1fabebf..937dda4 100644 --- a/crates/lune-std/src/globals/require/path.rs +++ b/crates/lune-std/src/globals/require/path.rs @@ -5,30 +5,24 @@ use mlua::Error::ExternalError; use super::context::*; -pub(super) async fn require<'lua, 'ctx>( - lua: &'lua Lua, - ctx: &'ctx RequireContext, +pub(super) async fn require( + lua: Lua, + ctx: &RequireContext, source: &str, path: &str, -) -> LuaResult> -where - 'lua: 'ctx, -{ +) -> LuaResult { let (abs_path, rel_path) = RequireContext::resolve_paths(source, path)?; require_abs_rel(lua, ctx, abs_path, rel_path).await } -pub(super) async fn require_abs_rel<'lua, 'ctx>( - lua: &'lua Lua, - ctx: &'ctx RequireContext, +pub(super) async fn require_abs_rel( + lua: Lua, + ctx: &RequireContext, abs_path: PathBuf, // Absolute to filesystem rel_path: PathBuf, // Relative to CWD (for displaying) -) -> LuaResult> -where - 'lua: 'ctx, -{ +) -> LuaResult { // 1. Try to require the exact path - match require_inner(lua, ctx, &abs_path, &rel_path).await { + match require_inner(lua.clone(), ctx, &abs_path, &rel_path).await { Ok(res) => return Ok(res), Err(err) => { if !is_file_not_found_error(&err) { @@ -41,7 +35,7 @@ where // 3. Try to require the path with an added "lua" extension for extension in ["luau", "lua"] { match require_inner( - lua, + lua.clone(), ctx, &append_extension(&abs_path, extension), &append_extension(&rel_path, extension), @@ -66,7 +60,7 @@ where // 5. Try to require the init path with an added "lua" extension for extension in ["luau", "lua"] { match require_inner( - lua, + lua.clone(), ctx, &append_extension(&abs_init, extension), &append_extension(&rel_init, extension), @@ -89,15 +83,12 @@ where ))) } -async fn require_inner<'lua, 'ctx>( - lua: &'lua Lua, - ctx: &'ctx RequireContext, +async fn require_inner( + lua: Lua, + ctx: &RequireContext, abs_path: impl AsRef, rel_path: impl AsRef, -) -> LuaResult> -where - 'lua: 'ctx, -{ +) -> LuaResult { let abs_path = abs_path.as_ref(); let rel_path = rel_path.as_ref(); diff --git a/crates/lune-std/src/globals/version.rs b/crates/lune-std/src/globals/version.rs index 3eface4..dedb916 100644 --- a/crates/lune-std/src/globals/version.rs +++ b/crates/lune-std/src/globals/version.rs @@ -6,13 +6,13 @@ struct Version(String); impl LuaUserData for Version {} -pub fn create(lua: &Lua) -> LuaResult { +pub fn create(lua: Lua) -> LuaResult { let v = match lua.app_data_ref::() { Some(v) => v.0.to_string(), None => env!("CARGO_PKG_VERSION").to_string(), }; let s = get_version_string(v); - lua.create_string(s)?.into_lua(lua) + lua.create_string(s)?.into_lua(&lua) } /** diff --git a/crates/lune-std/src/globals/warn.rs b/crates/lune-std/src/globals/warn.rs index ee42ddb..2bf7382 100644 --- a/crates/lune-std/src/globals/warn.rs +++ b/crates/lune-std/src/globals/warn.rs @@ -7,8 +7,8 @@ const FORMAT_CONFIG: ValueFormatConfig = ValueFormatConfig::new() .with_max_depth(4) .with_colors_enabled(true); -pub fn create(lua: &Lua) -> LuaResult { - let f = lua.create_function(|_, args: LuaMultiValue| { +pub fn create(lua: Lua) -> LuaResult { + let f = lua.create_function(|_: &Lua, args: LuaMultiValue| { let formatted = format!( "{}\n{}\n", Label::Warn, @@ -19,5 +19,5 @@ pub fn create(lua: &Lua) -> LuaResult { stdout.flush()?; Ok(()) })?; - f.into_lua(lua) + f.into_lua(&lua) } diff --git a/crates/lune-std/src/lib.rs b/crates/lune-std/src/lib.rs index a29bef0..9135020 100644 --- a/crates/lune-std/src/lib.rs +++ b/crates/lune-std/src/lib.rs @@ -21,9 +21,10 @@ pub use self::library::LuneStandardLibrary; Errors when out of memory, or if *default* Lua globals are missing. */ -pub fn inject_globals(lua: &Lua) -> LuaResult<()> { +pub fn inject_globals(lua: Lua) -> LuaResult<()> { for global in LuneStandardGlobal::ALL { - lua.globals().set(global.name(), global.create(lua)?)?; + lua.globals() + .set(global.name(), global.create(lua.clone())?)?; } Ok(()) } diff --git a/crates/lune-std/src/library.rs b/crates/lune-std/src/library.rs index 9a301f5..84c2a98 100644 --- a/crates/lune-std/src/library.rs +++ b/crates/lune-std/src/library.rs @@ -70,23 +70,24 @@ impl LuneStandardLibrary { */ #[rustfmt::skip] #[allow(unreachable_patterns)] - pub fn module<'lua>(&self, lua: &'lua Lua) -> LuaResult> { + pub fn module(&self, lua: Lua) -> LuaResult { + let mod_lua = lua.clone(); let res: LuaResult = match self { - #[cfg(feature = "datetime")] Self::DateTime => lune_std_datetime::module(lua), - #[cfg(feature = "fs")] Self::Fs => lune_std_fs::module(lua), - #[cfg(feature = "luau")] Self::Luau => lune_std_luau::module(lua), - #[cfg(feature = "net")] Self::Net => lune_std_net::module(lua), - #[cfg(feature = "task")] Self::Task => lune_std_task::module(lua), - #[cfg(feature = "process")] Self::Process => lune_std_process::module(lua), - #[cfg(feature = "regex")] Self::Regex => lune_std_regex::module(lua), - #[cfg(feature = "serde")] Self::Serde => lune_std_serde::module(lua), - #[cfg(feature = "stdio")] Self::Stdio => lune_std_stdio::module(lua), - #[cfg(feature = "roblox")] Self::Roblox => lune_std_roblox::module(lua), + #[cfg(feature = "datetime")] Self::DateTime => lune_std_datetime::module(mod_lua), + #[cfg(feature = "fs")] Self::Fs => lune_std_fs::module(mod_lua), + #[cfg(feature = "luau")] Self::Luau => lune_std_luau::module(mod_lua), + #[cfg(feature = "net")] Self::Net => lune_std_net::module(mod_lua), + #[cfg(feature = "task")] Self::Task => lune_std_task::module(mod_lua), + #[cfg(feature = "process")] Self::Process => lune_std_process::module(mod_lua), + #[cfg(feature = "regex")] Self::Regex => lune_std_regex::module(mod_lua), + #[cfg(feature = "serde")] Self::Serde => lune_std_serde::module(mod_lua), + #[cfg(feature = "stdio")] Self::Stdio => lune_std_stdio::module(mod_lua), + #[cfg(feature = "roblox")] Self::Roblox => lune_std_roblox::module(mod_lua), _ => unreachable!("no standard library enabled"), }; match res { - Ok(v) => v.into_lua_multi(lua), + Ok(v) => v.into_lua_multi(&lua), Err(e) => Err(e.context(format!( "Failed to create standard library '{}'", self.name() diff --git a/crates/lune-utils/Cargo.toml b/crates/lune-utils/Cargo.toml index eb43dcc..1b08437 100644 --- a/crates/lune-utils/Cargo.toml +++ b/crates/lune-utils/Cargo.toml @@ -13,7 +13,7 @@ path = "src/lib.rs" workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau", "async"] } +mlua = { version = "0.10.3", features = ["luau", "async"] } tokio = { version = "1", default-features = false, features = ["fs"] } diff --git a/crates/lune-utils/src/fmt/error/components.rs b/crates/lune-utils/src/fmt/error/components.rs index c6333e6..79b983a 100644 --- a/crates/lune-utils/src/fmt/error/components.rs +++ b/crates/lune-utils/src/fmt/error/components.rs @@ -118,6 +118,7 @@ impl From for ErrorComponents { // Extract any additional "context" messages before the actual error(s) // The Arc is necessary here because mlua wraps all inner errors in an Arc + #[allow(clippy::arc_with_non_send_sync)] let mut error = Arc::new(error); let mut messages = Vec::new(); while let LuaError::WithContext { @@ -195,3 +196,9 @@ impl From for ErrorComponents { ErrorComponents { messages, trace } } } + +impl From> for ErrorComponents { + fn from(value: Box) -> Self { + Self::from(*value) + } +} diff --git a/crates/lune-utils/src/fmt/error/tests.rs b/crates/lune-utils/src/fmt/error/tests.rs index 963a0af..dcc9207 100644 --- a/crates/lune-utils/src/fmt/error/tests.rs +++ b/crates/lune-utils/src/fmt/error/tests.rs @@ -8,9 +8,7 @@ fn new_lua_runtime_error() -> LuaResult<()> { lua.globals() .set( "f", - LuaFunction::wrap(|_, (): ()| { - Err::<(), _>(LuaError::runtime("oh no, a runtime error")) - }), + LuaFunction::wrap(|(): ()| Err::<(), _>(LuaError::runtime("oh no, a runtime error"))), ) .unwrap(); diff --git a/crates/lune-utils/src/fmt/value/basic.rs b/crates/lune-utils/src/fmt/value/basic.rs index ff1f421..8ccafaa 100644 --- a/crates/lune-utils/src/fmt/value/basic.rs +++ b/crates/lune-utils/src/fmt/value/basic.rs @@ -56,6 +56,8 @@ pub(crate) fn format_value_styled(value: &LuaValue, prefer_plain: bool) -> Strin format!(r#""{s}""#) }) .to_string(), + LuaValue::Other(_) => COLOR_MAGENTA.apply_to("").to_string(), + LuaValue::Buffer(_) => COLOR_MAGENTA.apply_to("").to_string(), LuaValue::Vector(_) => COLOR_MAGENTA.apply_to("").to_string(), LuaValue::Thread(_) => COLOR_MAGENTA.apply_to("").to_string(), LuaValue::Function(_) => COLOR_MAGENTA.apply_to("").to_string(), diff --git a/crates/lune-utils/src/fmt/value/metamethods.rs b/crates/lune-utils/src/fmt/value/metamethods.rs index c553262..d0300ce 100644 --- a/crates/lune-utils/src/fmt/value/metamethods.rs +++ b/crates/lune-utils/src/fmt/value/metamethods.rs @@ -1,17 +1,17 @@ use mlua::prelude::*; -pub fn get_table_type_metavalue<'a>(tab: &'a LuaTable<'a>) -> Option { +pub fn get_table_type_metavalue(tab: &LuaTable) -> Option { let s = tab - .get_metatable()? - .get::<_, LuaString>(LuaMetaMethod::Type.name()) + .metatable()? + .get::(LuaMetaMethod::Type.name()) .ok()?; let s = s.to_str().ok()?; Some(s.to_string()) } -pub fn get_userdata_type_metavalue<'a>(tab: &'a LuaAnyUserData<'a>) -> Option { +pub fn get_userdata_type_metavalue(tab: &LuaAnyUserData) -> Option { let s = tab - .get_metatable() + .metatable() .ok()? .get::(LuaMetaMethod::Type.name()) .ok()?; @@ -19,16 +19,16 @@ pub fn get_userdata_type_metavalue<'a>(tab: &'a LuaAnyUserData<'a>) -> Option(tab: &'a LuaTable<'a>) -> Option { - tab.get_metatable()? - .get::<_, LuaFunction>(LuaMetaMethod::ToString.name()) +pub fn call_table_tostring_metamethod(tab: &LuaTable) -> Option { + tab.metatable()? + .get::(LuaMetaMethod::ToString.name()) .ok()? .call(tab) .ok() } -pub fn call_userdata_tostring_metamethod<'a>(tab: &'a LuaAnyUserData<'a>) -> Option { - tab.get_metatable() +pub fn call_userdata_tostring_metamethod(tab: &LuaAnyUserData) -> Option { + tab.metatable() .ok()? .get::(LuaMetaMethod::ToString.name()) .ok()? diff --git a/crates/lune-utils/src/fmt/value/recursive.rs b/crates/lune-utils/src/fmt/value/recursive.rs index ca20429..d704222 100644 --- a/crates/lune-utils/src/fmt/value/recursive.rs +++ b/crates/lune-utils/src/fmt/value/recursive.rs @@ -19,13 +19,13 @@ const INDENT: &str = " "; #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub(crate) struct LuaValueId(usize); -impl From<&LuaValue<'_>> for LuaValueId { - fn from(value: &LuaValue<'_>) -> Self { +impl From<&LuaValue> for LuaValueId { + fn from(value: &LuaValue) -> Self { Self(value.to_pointer() as usize) } } -impl From<&LuaTable<'_>> for LuaValueId { +impl From<&LuaTable> for LuaValueId { fn from(table: &LuaTable) -> Self { Self(table.to_pointer() as usize) } diff --git a/crates/lune-utils/src/jit.rs b/crates/lune-utils/src/jit.rs index e2ee475..e5bb80d 100644 --- a/crates/lune-utils/src/jit.rs +++ b/crates/lune-utils/src/jit.rs @@ -1,7 +1,7 @@ #[derive(Debug, Clone, Copy, Default)] -pub struct JitStatus(bool); +pub struct JitEnablement(bool); -impl JitStatus { +impl JitEnablement { #[must_use] pub fn new(enabled: bool) -> Self { Self(enabled) @@ -17,13 +17,13 @@ impl JitStatus { } } -impl From for bool { - fn from(val: JitStatus) -> Self { +impl From for bool { + fn from(val: JitEnablement) -> Self { val.enabled() } } -impl From for JitStatus { +impl From for JitEnablement { fn from(val: bool) -> Self { Self::new(val) } diff --git a/crates/lune-utils/src/table_builder.rs b/crates/lune-utils/src/table_builder.rs index 1678902..1558e40 100644 --- a/crates/lune-utils/src/table_builder.rs +++ b/crates/lune-utils/src/table_builder.rs @@ -7,16 +7,16 @@ use mlua::prelude::*; /** Utility struct for building Lua tables. */ -pub struct TableBuilder<'lua> { - lua: &'lua Lua, - tab: LuaTable<'lua>, +pub struct TableBuilder { + lua: Lua, + tab: LuaTable, } -impl<'lua> TableBuilder<'lua> { +impl TableBuilder { /** Creates a new table builder. */ - pub fn new(lua: &'lua Lua) -> LuaResult { + pub fn new(lua: Lua) -> LuaResult { let tab = lua.create_table()?; Ok(Self { lua, tab }) } @@ -28,8 +28,8 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_value(self, key: K, value: V) -> LuaResult where - K: IntoLua<'lua>, - V: IntoLua<'lua>, + K: IntoLua, + V: IntoLua, { self.tab.raw_set(key, value)?; Ok(self) @@ -42,8 +42,8 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_values(self, values: Vec<(K, V)>) -> LuaResult where - K: IntoLua<'lua>, - V: IntoLua<'lua>, + K: IntoLua, + V: IntoLua, { for (key, value) in values { self.tab.raw_set(key, value)?; @@ -59,7 +59,7 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_sequential_value(self, value: V) -> LuaResult where - V: IntoLua<'lua>, + V: IntoLua, { self.tab.raw_push(value)?; Ok(self) @@ -73,7 +73,7 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_sequential_values(self, values: Vec) -> LuaResult where - V: IntoLua<'lua>, + V: IntoLua, { for value in values { self.tab.raw_push(value)?; @@ -88,10 +88,10 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_function(self, key: K, func: F) -> LuaResult where - K: IntoLua<'lua>, - A: FromLuaMulti<'lua>, - R: IntoLuaMulti<'lua>, - F: Fn(&'lua Lua, A) -> LuaResult + 'static, + K: IntoLua, + A: FromLuaMulti, + R: IntoLuaMulti, + F: Fn(&Lua, A) -> LuaResult + 'static, { let f = self.lua.create_function(func)?; self.with_value(key, LuaValue::Function(f)) @@ -104,11 +104,11 @@ impl<'lua> TableBuilder<'lua> { */ pub fn with_async_function(self, key: K, func: F) -> LuaResult where - K: IntoLua<'lua>, - A: FromLuaMulti<'lua>, - R: IntoLuaMulti<'lua>, - F: Fn(&'lua Lua, A) -> FR + 'static, - FR: Future> + 'lua, + K: IntoLua, + A: FromLuaMulti, + R: IntoLuaMulti, + F: Fn(Lua, A) -> FR + 'static, + FR: Future> + 'static, { let f = self.lua.create_async_function(func)?; self.with_value(key, LuaValue::Function(f)) @@ -129,7 +129,7 @@ impl<'lua> TableBuilder<'lua> { This will prevent any *direct* modifications to the table. */ - pub fn build_readonly(self) -> LuaResult> { + pub fn build_readonly(self) -> LuaResult { self.tab.set_readonly(true); Ok(self.tab) } @@ -137,7 +137,7 @@ impl<'lua> TableBuilder<'lua> { /** Builds the table. */ - pub fn build(self) -> LuaResult> { + pub fn build(self) -> LuaResult { Ok(self.tab) } } diff --git a/crates/lune-utils/src/version_string.rs b/crates/lune-utils/src/version_string.rs index 19a10ce..ca13e84 100644 --- a/crates/lune-utils/src/version_string.rs +++ b/crates/lune-utils/src/version_string.rs @@ -33,7 +33,7 @@ fn create_luau_version_string() -> Arc { let luau_version_full = temp_lua .globals() - .get::<_, LuaString>("_VERSION") + .get::("_VERSION") .expect("Missing _VERSION global"); luau_version_full diff --git a/crates/lune/Cargo.toml b/crates/lune/Cargo.toml index 47e6b76..ef482f4 100644 --- a/crates/lune/Cargo.toml +++ b/crates/lune/Cargo.toml @@ -50,7 +50,7 @@ cli = ["dep:clap", "dep:include_dir", "dep:rustyline", "dep:zip_next"] workspace = true [dependencies] -mlua = { version = "0.9.9", features = ["luau"] } +mlua = { version = "0.10.3", features = ["luau"] } mlua-luau-scheduler = { version = "0.0.2", path = "../mlua-luau-scheduler" } anyhow = "1.0" diff --git a/crates/lune/src/cli/repl.rs b/crates/lune/src/cli/repl.rs index c593fd1..480142d 100644 --- a/crates/lune/src/cli/repl.rs +++ b/crates/lune/src/cli/repl.rs @@ -38,7 +38,7 @@ impl ReplCommand { let mut prompt_state = PromptState::Regular; let mut source_code = String::new(); - let mut lune_instance = Runtime::new(); + let mut lune_instance = Runtime::new()?; loop { let prompt = match prompt_state { diff --git a/crates/lune/src/cli/run.rs b/crates/lune/src/cli/run.rs index dd1fa63..65df5ed 100644 --- a/crates/lune/src/cli/run.rs +++ b/crates/lune/src/cli/run.rs @@ -40,18 +40,15 @@ impl RunCommand { (file_display_name, file_contents) }; - // Create a new lune runtime with all globals & run the script - let mut rt = Runtime::new() - .with_args(self.script_args) - // Enable JIT compilation unless it was requested to be disabled - .with_jit( - !matches!( - env::var("LUNE_LUAU_JIT").ok(), - Some(jit_enabled) if jit_enabled == "0" || jit_enabled == "false" || jit_enabled == "off" - ) - ); + // Check if the user has explicitly disabled JIT (on by default) + let jit_disabled = env::var("LUNE_LUAU_JIT") + .ok() + .is_some_and(|s| matches!(s.as_str(), "0" | "false" | "off")); - let result = rt + // Create a new lune runtime with all globals & run the script + let result = Runtime::new()? + .with_args(self.script_args) + .with_jit(!jit_disabled) .run(&script_display_name, strip_shebang(script_contents)) .await; diff --git a/crates/lune/src/rt/runtime.rs b/crates/lune/src/rt/runtime.rs index 3f7cce6..3a05243 100644 --- a/crates/lune/src/rt/runtime.rs +++ b/crates/lune/src/rt/runtime.rs @@ -1,107 +1,23 @@ #![allow(clippy::missing_panics_doc)] -use std::{ - rc::Rc, - sync::{ - atomic::{AtomicBool, Ordering}, - Arc, - }, +use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, }; -use lune_utils::jit::JitStatus; +use lune_utils::jit::JitEnablement; use mlua::prelude::*; use mlua_luau_scheduler::{Functions, Scheduler}; -use self_cell::self_cell; use super::{RuntimeError, RuntimeResult}; -// NOTE: We need to use self_cell to create a self-referential -// struct storing both the Lua VM and the scheduler. The scheduler -// needs to be created at the same time so that we can also create -// and inject the scheduler functions which will be used across runs. -self_cell! { - struct RuntimeInner { - owner: Rc, - #[covariant] - dependent: Scheduler, - } -} - -impl RuntimeInner { - fn create() -> LuaResult { - let lua = Rc::new(Lua::new()); - - lua.set_app_data(Rc::downgrade(&lua)); - lua.set_app_data(Vec::::new()); - - Self::try_new(lua, |lua| { - let sched = Scheduler::new(lua); - let fns = Functions::new(lua)?; - - // Overwrite some globals that are not compatible with our scheduler - let co = lua.globals().get::<_, LuaTable>("coroutine")?; - co.set("resume", fns.resume.clone())?; - co.set("wrap", fns.wrap.clone())?; - - // Inject all the globals that are enabled - #[cfg(any( - feature = "std-datetime", - feature = "std-fs", - feature = "std-luau", - feature = "std-net", - feature = "std-process", - feature = "std-regex", - feature = "std-roblox", - feature = "std-serde", - feature = "std-stdio", - feature = "std-task", - ))] - { - lune_std::set_global_version(lua, env!("CARGO_PKG_VERSION")); - lune_std::inject_globals(lua)?; - } - - // Sandbox the Luau VM and make it go zooooooooom - lua.sandbox(true)?; - - // _G table needs to be injected again after sandboxing, - // otherwise it will be read-only and completely unusable - #[cfg(any( - feature = "std-datetime", - feature = "std-fs", - feature = "std-luau", - feature = "std-net", - feature = "std-process", - feature = "std-regex", - feature = "std-roblox", - feature = "std-serde", - feature = "std-stdio", - feature = "std-task", - ))] - { - let g_table = lune_std::LuneStandardGlobal::GTable; - lua.globals().set(g_table.name(), g_table.create(lua)?)?; - } - - Ok(sched) - }) - } - - fn lua(&self) -> &Lua { - self.borrow_owner() - } - - fn scheduler(&self) -> &Scheduler { - self.borrow_dependent() - } -} - /** A Lune runtime. */ pub struct Runtime { - inner: RuntimeInner, - jit_status: JitStatus, + lua: Lua, + sched: Scheduler, + jit: JitEnablement, } impl Runtime { @@ -109,14 +25,68 @@ impl Runtime { Creates a new Lune runtime, with a new Luau VM. Injects standard globals and libraries if any of the `std` features are enabled. + + # Errors + + - If out of memory or other memory-related errors occur + - If any of the standard globals and libraries fail to inject */ - #[must_use] - #[allow(clippy::new_without_default)] - pub fn new() -> Self { - Self { - inner: RuntimeInner::create().expect("Failed to create runtime"), - jit_status: JitStatus::default(), + pub fn new() -> LuaResult { + let lua = Lua::new(); + + lua.set_app_data(Vec::::new()); + + let sched = Scheduler::new(lua.clone()); + let fns = Functions::new(lua.clone()).expect("has scheduler"); + + // Overwrite some globals that are not compatible with our scheduler + let co = lua.globals().get::("coroutine")?; + co.set("resume", fns.resume.clone())?; + co.set("wrap", fns.wrap.clone())?; + + // Inject all the globals that are enabled + #[cfg(any( + feature = "std-datetime", + feature = "std-fs", + feature = "std-luau", + feature = "std-net", + feature = "std-process", + feature = "std-regex", + feature = "std-roblox", + feature = "std-serde", + feature = "std-stdio", + feature = "std-task", + ))] + { + lune_std::set_global_version(&lua, env!("CARGO_PKG_VERSION")); + lune_std::inject_globals(lua.clone())?; } + + // Sandbox the Luau VM and make it go zooooooooom + lua.sandbox(true)?; + + // _G table needs to be injected again after sandboxing, + // otherwise it will be read-only and completely unusable + #[cfg(any( + feature = "std-datetime", + feature = "std-fs", + feature = "std-luau", + feature = "std-net", + feature = "std-process", + feature = "std-regex", + feature = "std-roblox", + feature = "std-serde", + feature = "std-stdio", + feature = "std-task", + ))] + { + let g_table = lune_std::LuneStandardGlobal::GTable; + lua.globals() + .set(g_table.name(), g_table.create(lua.clone())?)?; + } + + let jit = JitEnablement::default(); + Ok(Self { lua, sched, jit }) } /** @@ -129,7 +99,7 @@ impl Runtime { S: Into, { let args = args.into_iter().map(Into::into).collect::>(); - self.inner.lua().set_app_data(args); + self.lua.set_app_data(args); self } @@ -137,8 +107,8 @@ impl Runtime { Enables or disables JIT compilation. */ #[must_use] - pub fn with_jit(mut self, jit_status: impl Into) -> Self { - self.jit_status = jit_status.into(); + pub fn with_jit(mut self, jit_status: impl Into) -> Self { + self.jit = jit_status.into(); self } @@ -156,37 +126,35 @@ impl Runtime { script_name: impl AsRef, script_contents: impl AsRef<[u8]>, ) -> RuntimeResult<(u8, Vec)> { - let lua = self.inner.lua(); - let sched = self.inner.scheduler(); - // Add error callback to format errors nicely + store status let got_any_error = Arc::new(AtomicBool::new(false)); let got_any_inner = Arc::clone(&got_any_error); - self.inner.scheduler().set_error_callback(move |e| { + self.sched.set_error_callback(move |e| { got_any_inner.store(true, Ordering::SeqCst); eprintln!("{}", RuntimeError::from(e)); }); // Enable / disable the JIT as requested and store the current status as AppData - lua.set_app_data(self.jit_status); - lua.enable_jit(self.jit_status.enabled()); + self.lua.set_app_data(self.jit); + self.lua.enable_jit(self.jit.enabled()); // Load our "main" thread - let main = lua + let main = self + .lua .load(script_contents.as_ref()) .set_name(script_name.as_ref()); // Run it on our scheduler until it and any other spawned threads complete - let main_thread_id = sched.push_thread_back(main, ())?; - sched.run().await; + let main_thread_id = self.sched.push_thread_back(main, ())?; + self.sched.run().await; - let main_thread_res = match sched.get_thread_result(main_thread_id) { + let main_thread_res = match self.sched.get_thread_result(main_thread_id) { Some(res) => res, - None => LuaValue::Nil.into_lua_multi(lua), + None => LuaValue::Nil.into_lua_multi(&self.lua), }?; Ok(( - sched + self.sched .get_exit_code() .unwrap_or(u8::from(got_any_error.load(Ordering::SeqCst))), main_thread_res.into_vec(), diff --git a/crates/lune/src/standalone/metadata.rs b/crates/lune/src/standalone/metadata.rs index 3bc5cb9..0fe14fa 100644 --- a/crates/lune/src/standalone/metadata.rs +++ b/crates/lune/src/standalone/metadata.rs @@ -59,7 +59,7 @@ impl Metadata { let mut patched_bin = fs::read(base_exe_path).await?; // Compile luau input into bytecode - let bytecode = compiler.compile(script_contents.into()); + let bytecode = compiler.compile(script_contents.into())?; // Append the bytecode / metadata to the end let meta = Self { bytecode }; diff --git a/crates/lune/src/standalone/mod.rs b/crates/lune/src/standalone/mod.rs index 40321dd..2bbc7c0 100644 --- a/crates/lune/src/standalone/mod.rs +++ b/crates/lune/src/standalone/mod.rs @@ -29,7 +29,7 @@ pub async fn run(patched_bin: impl AsRef<[u8]>) -> Result { let args = env::args().skip(1).collect::>(); let meta = Metadata::from_bytes(patched_bin).expect("must be a standalone binary"); - let mut rt = Runtime::new().with_args(args); + let mut rt = Runtime::new()?.with_args(args); let result = rt.run("STANDALONE", meta.bytecode).await; diff --git a/crates/lune/src/tests.rs b/crates/lune/src/tests.rs index 8ef206d..08cd239 100644 --- a/crates/lune/src/tests.rs +++ b/crates/lune/src/tests.rs @@ -31,7 +31,7 @@ macro_rules! create_tests { // The rest of the test logic can continue as normal let full_name = format!("{}/tests/{}.luau", workspace_dir.display(), $value); let script = read_to_string(&full_name).await?; - let mut lune = Runtime::new() + let mut lune = Runtime::new()? .with_jit(true) .with_args( ARGS diff --git a/crates/mlua-luau-scheduler/Cargo.toml b/crates/mlua-luau-scheduler/Cargo.toml index e2cca4e..b295cf4 100644 --- a/crates/mlua-luau-scheduler/Cargo.toml +++ b/crates/mlua-luau-scheduler/Cargo.toml @@ -25,7 +25,7 @@ futures-lite = "2.2" rustc-hash = "1.1" tracing = "0.1" -mlua = { version = "0.9.9", features = [ +mlua = { version = "0.10.3", features = [ "luau", "luau-jit", "async", diff --git a/crates/mlua-luau-scheduler/examples/basic_sleep.rs b/crates/mlua-luau-scheduler/examples/basic_sleep.rs index 228591d..6db84b2 100644 --- a/crates/mlua-luau-scheduler/examples/basic_sleep.rs +++ b/crates/mlua-luau-scheduler/examples/basic_sleep.rs @@ -29,7 +29,7 @@ pub fn main() -> LuaResult<()> { )?; // Load the main script into a scheduler - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); let main = lua.load(MAIN_SCRIPT); sched.push_thread_front(main, ())?; diff --git a/crates/mlua-luau-scheduler/examples/basic_spawn.rs b/crates/mlua-luau-scheduler/examples/basic_spawn.rs index 8e65a1a..0f35faf 100644 --- a/crates/mlua-luau-scheduler/examples/basic_spawn.rs +++ b/crates/mlua-luau-scheduler/examples/basic_spawn.rs @@ -48,7 +48,7 @@ pub fn main() -> LuaResult<()> { )?; // Load the main script into a scheduler - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); let main = lua.load(MAIN_SCRIPT); sched.push_thread_front(main, ())?; diff --git a/crates/mlua-luau-scheduler/examples/callbacks.rs b/crates/mlua-luau-scheduler/examples/callbacks.rs index 44a28fe..4fe7fb9 100644 --- a/crates/mlua-luau-scheduler/examples/callbacks.rs +++ b/crates/mlua-luau-scheduler/examples/callbacks.rs @@ -20,7 +20,7 @@ pub fn main() -> LuaResult<()> { let lua = Lua::new(); // Create a new scheduler with custom callbacks - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); sched.set_error_callback(|e| { println!( "Captured error from Lua!\n{}\n{e}\n{}", diff --git a/crates/mlua-luau-scheduler/examples/exit_code.rs b/crates/mlua-luau-scheduler/examples/exit_code.rs index a6ede57..090d443 100644 --- a/crates/mlua-luau-scheduler/examples/exit_code.rs +++ b/crates/mlua-luau-scheduler/examples/exit_code.rs @@ -18,8 +18,8 @@ pub fn main() -> LuaResult<()> { // Set up persistent Lua environment let lua = Lua::new(); - let sched = Scheduler::new(&lua); - let fns = Functions::new(&lua)?; + let sched = Scheduler::new(lua.clone()); + let fns = Functions::new(lua.clone())?; lua.globals().set("exit", fns.exit)?; diff --git a/crates/mlua-luau-scheduler/examples/lots_of_threads.rs b/crates/mlua-luau-scheduler/examples/lots_of_threads.rs index 33451aa..48e07db 100644 --- a/crates/mlua-luau-scheduler/examples/lots_of_threads.rs +++ b/crates/mlua-luau-scheduler/examples/lots_of_threads.rs @@ -21,8 +21,8 @@ pub fn main() -> LuaResult<()> { // Set up persistent Lua environment let lua = Lua::new(); - let sched = Scheduler::new(&lua); - let fns = Functions::new(&lua)?; + let sched = Scheduler::new(lua.clone()); + let fns = Functions::new(lua.clone())?; lua.globals().set("spawn", fns.spawn)?; lua.globals().set( diff --git a/crates/mlua-luau-scheduler/examples/scheduler_ordering.rs b/crates/mlua-luau-scheduler/examples/scheduler_ordering.rs index 2fd4181..56c3da5 100644 --- a/crates/mlua-luau-scheduler/examples/scheduler_ordering.rs +++ b/crates/mlua-luau-scheduler/examples/scheduler_ordering.rs @@ -20,8 +20,8 @@ pub fn main() -> LuaResult<()> { // Set up persistent Lua environment let lua = Lua::new(); - let sched = Scheduler::new(&lua); - let fns = Functions::new(&lua)?; + let sched = Scheduler::new(lua.clone()); + let fns = Functions::new(lua.clone())?; lua.globals().set("spawn", fns.spawn)?; lua.globals().set("defer", fns.defer)?; diff --git a/crates/mlua-luau-scheduler/examples/tracy.rs b/crates/mlua-luau-scheduler/examples/tracy.rs index 01732c3..3d6eeca 100644 --- a/crates/mlua-luau-scheduler/examples/tracy.rs +++ b/crates/mlua-luau-scheduler/examples/tracy.rs @@ -36,8 +36,8 @@ pub fn main() -> LuaResult<()> { // Set up persistent Lua environment let lua = Lua::new(); - let sched = Scheduler::new(&lua); - let fns = Functions::new(&lua)?; + let sched = Scheduler::new(lua.clone()); + let fns = Functions::new(lua.clone())?; lua.globals().set("spawn", fns.spawn)?; lua.globals().set( diff --git a/crates/mlua-luau-scheduler/src/functions.rs b/crates/mlua-luau-scheduler/src/functions.rs index 920cc85..307d0f1 100644 --- a/crates/mlua-luau-scheduler/src/functions.rs +++ b/crates/mlua-luau-scheduler/src/functions.rs @@ -40,44 +40,44 @@ end Note that these may all be implemented using [`LuaSchedulerExt`], however, this struct is implemented using internal (non-public) APIs, and generally has better performance. */ -pub struct Functions<'lua> { +pub struct Functions { /** Implementation of `coroutine.resume` that handles async polling properly. Defers onto the scheduler queue if the thread calls an async function. */ - pub resume: LuaFunction<'lua>, + pub resume: LuaFunction, /** Implementation of `coroutine.wrap` that handles async polling properly. Defers onto the scheduler queue if the thread calls an async function. */ - pub wrap: LuaFunction<'lua>, + pub wrap: LuaFunction, /** Resumes a function / thread once instantly, and runs until first yield. Spawns onto the scheduler queue if not completed. */ - pub spawn: LuaFunction<'lua>, + pub spawn: LuaFunction, /** Defers a function / thread onto the scheduler queue. Does not resume instantly, only adds to the queue. */ - pub defer: LuaFunction<'lua>, + pub defer: LuaFunction, /** Cancels a function / thread, removing it from the queue. */ - pub cancel: LuaFunction<'lua>, + pub cancel: LuaFunction, /** Exits the scheduler, stopping all other threads and closing the scheduler. Yields the calling thread to ensure that it does not continue. */ - pub exit: LuaFunction<'lua>, + pub exit: LuaFunction, } -impl<'lua> Functions<'lua> { +impl Functions { /** Creates a new collection of Lua functions that may be called to interact with a [`Scheduler`]. @@ -89,7 +89,7 @@ impl<'lua> Functions<'lua> { Panics when the given [`Lua`] instance does not have an attached [`Scheduler`]. */ - pub fn new(lua: &'lua Lua) -> LuaResult { + pub fn new(lua: Lua) -> LuaResult { let spawn_queue = lua .app_data_ref::() .expect(ERR_METADATA_NOT_ATTACHED) @@ -112,9 +112,9 @@ impl<'lua> Functions<'lua> { let resume = lua.create_function(move |lua, (thread, args): (LuaThread, LuaMultiValue)| { let _span = tracing::trace_span!("Scheduler::fn_resume").entered(); - match thread.resume::<_, LuaMultiValue>(args.clone()) { + match thread.resume::(args.clone()) { Ok(v) => { - if v.get(0).is_some_and(is_poll_pending) { + if v.front().is_some_and(is_poll_pending) { // Pending, defer to scheduler and return nil resume_queue.push_item(lua, &thread, args)?; (true, LuaValue::Nil).into_lua_multi(lua) @@ -144,14 +144,14 @@ impl<'lua> Functions<'lua> { let wrap_env = lua.create_table_from(vec![ ("resume", resume.clone()), - ("error", lua.globals().get::<_, LuaFunction>("error")?), - ("select", lua.globals().get::<_, LuaFunction>("select")?), - ("unpack", lua.globals().get::<_, LuaFunction>("unpack")?), + ("error", lua.globals().get::("error")?), + ("select", lua.globals().get::("select")?), + ("unpack", lua.globals().get::("unpack")?), ( "create", lua.globals() - .get::<_, LuaTable>("coroutine")? - .get::<_, LuaFunction>("create")?, + .get::("coroutine")? + .get::("create")?, ), ])?; let wrap = lua @@ -168,9 +168,9 @@ impl<'lua> Functions<'lua> { if thread.status() == LuaThreadStatus::Resumable { // NOTE: We need to resume the thread once instantly for correct behavior, // and only if we get the pending value back we can spawn to async executor - match thread.resume::<_, LuaMultiValue>(args.clone()) { + match thread.resume::(args.clone()) { Ok(v) => { - if v.get(0).is_some_and(is_poll_pending) { + if v.front().is_some_and(is_poll_pending) { spawn_queue.push_item(lua, &thread, args)?; } else { // Not pending, store the value if thread is done @@ -192,7 +192,7 @@ impl<'lua> Functions<'lua> { spawn_map.insert(id, res); } } - }; + } } Ok(thread) }, @@ -211,14 +211,14 @@ impl<'lua> Functions<'lua> { let close = lua .globals() - .get::<_, LuaTable>("coroutine")? - .get::<_, LuaFunction>("close")?; + .get::("coroutine")? + .get::("close")?; let close_key = lua.create_registry_value(close)?; let cancel = lua.create_function(move |lua, thread: LuaThread| { let _span = tracing::trace_span!("Scheduler::fn_cancel").entered(); let close: LuaFunction = lua.registry_value(&close_key)?; match close.call(thread) { - Err(LuaError::CoroutineInactive) | Ok(()) => Ok(()), + Err(LuaError::CoroutineUnresumable) | Ok(()) => Ok(()), Err(e) => Err(e), } })?; @@ -236,8 +236,8 @@ impl<'lua> Functions<'lua> { ( "yield", lua.globals() - .get::<_, LuaTable>("coroutine")? - .get::<_, LuaFunction>("yield")?, + .get::("coroutine")? + .get::("yield")?, ), ])?; let exit = lua @@ -257,7 +257,7 @@ impl<'lua> Functions<'lua> { } } -impl Functions<'_> { +impl Functions { /** Injects [`Scheduler`]-compatible functions into the given [`Lua`] instance. diff --git a/crates/mlua-luau-scheduler/src/queue.rs b/crates/mlua-luau-scheduler/src/queue.rs index aabb259..3d17249 100644 --- a/crates/mlua-luau-scheduler/src/queue.rs +++ b/crates/mlua-luau-scheduler/src/queue.rs @@ -27,11 +27,11 @@ impl ThreadQueue { Self { queue, event } } - pub fn push_item<'lua>( + pub fn push_item( &self, - lua: &'lua Lua, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + lua: &Lua, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult { let thread = thread.into_lua_thread(lua)?; let args = args.into_lua_multi(lua)?; @@ -50,7 +50,7 @@ impl ThreadQueue { pub fn drain_items<'outer, 'lua>( &'outer self, lua: &'lua Lua, - ) -> impl Iterator, LuaMultiValue<'lua>)> + 'outer + ) -> impl Iterator + 'outer where 'lua: 'outer, { diff --git a/crates/mlua-luau-scheduler/src/scheduler.rs b/crates/mlua-luau-scheduler/src/scheduler.rs index 9a43aa3..7e1eded 100644 --- a/crates/mlua-luau-scheduler/src/scheduler.rs +++ b/crates/mlua-luau-scheduler/src/scheduler.rs @@ -43,8 +43,8 @@ Cannot set error callback when scheduler is running!\ A scheduler for running Lua threads and async tasks. */ #[derive(Clone)] -pub struct Scheduler<'lua> { - lua: &'lua Lua, +pub struct Scheduler { + lua: Lua, queue_spawn: SpawnedThreadQueue, queue_defer: DeferredThreadQueue, error_callback: ThreadErrorCallback, @@ -53,7 +53,7 @@ pub struct Scheduler<'lua> { exit: Exit, } -impl<'lua> Scheduler<'lua> { +impl Scheduler { /** Creates a new scheduler for the given Lua state. @@ -64,7 +64,7 @@ impl<'lua> Scheduler<'lua> { Panics if the given Lua state already has a scheduler attached to it. */ #[must_use] - pub fn new(lua: &'lua Lua) -> Scheduler<'lua> { + pub fn new(lua: Lua) -> Scheduler { let queue_spawn = SpawnedThreadQueue::new(); let queue_defer = DeferredThreadQueue::new(); let error_callback = ThreadErrorCallback::default(); @@ -197,10 +197,10 @@ impl<'lua> Scheduler<'lua> { */ pub fn push_thread_front( &self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult { - let id = self.queue_spawn.push_item(self.lua, thread, args)?; + let id = self.queue_spawn.push_item(&self.lua, thread, args)?; self.result_map.track(id); Ok(id) } @@ -224,10 +224,10 @@ impl<'lua> Scheduler<'lua> { */ pub fn push_thread_back( &self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult { - let id = self.queue_defer.push_item(self.lua, thread, args)?; + let id = self.queue_defer.push_item(&self.lua, thread, args)?; self.result_map.track(id); Ok(id) } @@ -247,8 +247,8 @@ impl<'lua> Scheduler<'lua> { Any subsequent calls after this method returns `Some` will return `None`. */ #[must_use] - pub fn get_thread_result(&self, id: ThreadId) -> Option>> { - self.result_map.remove(id).map(|r| r.value(self.lua)) + pub fn get_thread_result(&self, id: ThreadId) -> Option> { + self.result_map.remove(id).map(|r| r.value(&self.lua)) } /** @@ -321,7 +321,7 @@ impl<'lua> Scheduler<'lua> { */ let fut = async { let result_map = self.result_map.clone(); - let process_thread = |thread: LuaThread<'lua>, args| { + let process_thread = |thread: LuaThread, args| { // NOTE: Thread may have been cancelled from Lua // before we got here, so we need to check it again if thread.status() == LuaThreadStatus::Resumable { @@ -342,7 +342,7 @@ impl<'lua> Scheduler<'lua> { self.error_callback.call(e); } if thread.status() != LuaThreadStatus::Resumable { - let thread_res = ThreadResult::new(res, self.lua); + let thread_res = ThreadResult::new(res, &self.lua); result_map_inner.unwrap().insert(id, thread_res); } } @@ -398,14 +398,14 @@ impl<'lua> Scheduler<'lua> { let mut num_futures = 0; { let _span = trace_span!("Scheduler::drain_spawned").entered(); - for (thread, args) in self.queue_spawn.drain_items(self.lua) { + for (thread, args) in self.queue_spawn.drain_items(&self.lua) { process_thread(thread, args); num_spawned += 1; } } { let _span = trace_span!("Scheduler::drain_deferred").entered(); - for (thread, args) in self.queue_defer.drain_items(self.lua) { + for (thread, args) in self.queue_defer.drain_items(&self.lua) { process_thread(thread, args); num_deferred += 1; } @@ -451,7 +451,7 @@ impl<'lua> Scheduler<'lua> { } } -impl Drop for Scheduler<'_> { +impl Drop for Scheduler { fn drop(&mut self) { if panicking() { // Do not cause further panics if already panicking, as diff --git a/crates/mlua-luau-scheduler/src/thread_id.rs b/crates/mlua-luau-scheduler/src/thread_id.rs index e2efcaa..89eb126 100644 --- a/crates/mlua-luau-scheduler/src/thread_id.rs +++ b/crates/mlua-luau-scheduler/src/thread_id.rs @@ -15,7 +15,7 @@ pub struct ThreadId { inner: usize, } -impl From<&LuaThread<'_>> for ThreadId { +impl From<&LuaThread> for ThreadId { fn from(thread: &LuaThread) -> Self { Self { inner: thread.to_pointer() as usize, diff --git a/crates/mlua-luau-scheduler/src/traits.rs b/crates/mlua-luau-scheduler/src/traits.rs index 943bc97..6c854ea 100644 --- a/crates/mlua-luau-scheduler/src/traits.rs +++ b/crates/mlua-luau-scheduler/src/traits.rs @@ -25,7 +25,7 @@ use crate::{ - Lua functions ([`LuaFunction`]) - Lua chunks ([`LuaChunk`]) */ -pub trait IntoLuaThread<'lua> { +pub trait IntoLuaThread { /** Converts the value into a Lua thread. @@ -33,32 +33,32 @@ pub trait IntoLuaThread<'lua> { Errors when out of memory. */ - fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult>; + fn into_lua_thread(self, lua: &Lua) -> LuaResult; } -impl<'lua> IntoLuaThread<'lua> for LuaThread<'lua> { - fn into_lua_thread(self, _: &'lua Lua) -> LuaResult> { +impl IntoLuaThread for LuaThread { + fn into_lua_thread(self, _: &Lua) -> LuaResult { Ok(self) } } -impl<'lua> IntoLuaThread<'lua> for LuaFunction<'lua> { - fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLuaThread for LuaFunction { + fn into_lua_thread(self, lua: &Lua) -> LuaResult { lua.create_thread(self) } } -impl<'lua> IntoLuaThread<'lua> for LuaChunk<'lua, '_> { - fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult> { +impl IntoLuaThread for LuaChunk<'_> { + fn into_lua_thread(self, lua: &Lua) -> LuaResult { lua.create_thread(self.into_function()?) } } -impl<'lua, T> IntoLuaThread<'lua> for &T +impl IntoLuaThread for &T where - T: IntoLuaThread<'lua> + Clone, + T: IntoLuaThread + Clone, { - fn into_lua_thread(self, lua: &'lua Lua) -> LuaResult> { + fn into_lua_thread(self, lua: &Lua) -> LuaResult { self.clone().into_lua_thread(lua) } } @@ -72,7 +72,7 @@ where - Pushing (spawning) and deferring (pushing to the back) lua threads - Tracking and getting the result of lua threads */ -pub trait LuaSchedulerExt<'lua> { +pub trait LuaSchedulerExt { /** Sets the exit code of the current scheduler. @@ -94,9 +94,9 @@ pub trait LuaSchedulerExt<'lua> { Panics if called outside of a running [`Scheduler`]. */ fn push_thread_front( - &'lua self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + &self, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult; /** @@ -109,9 +109,9 @@ pub trait LuaSchedulerExt<'lua> { Panics if called outside of a running [`Scheduler`]. */ fn push_thread_back( - &'lua self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + &self, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult; /** @@ -119,7 +119,7 @@ pub trait LuaSchedulerExt<'lua> { Must be called before waiting for a thread to complete or getting its result. */ - fn track_thread(&'lua self, id: ThreadId); + fn track_thread(&self, id: ThreadId); /** Gets the result of the given thread. @@ -130,7 +130,7 @@ pub trait LuaSchedulerExt<'lua> { Panics if called outside of a running [`Scheduler`]. */ - fn get_thread_result(&'lua self, id: ThreadId) -> Option>>; + fn get_thread_result(&self, id: ThreadId) -> Option>; /** Waits for the given thread to complete. @@ -141,7 +141,7 @@ pub trait LuaSchedulerExt<'lua> { Panics if called outside of a running [`Scheduler`]. */ - fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future; + fn wait_for_thread(&self, id: ThreadId) -> impl Future; } /** @@ -153,7 +153,7 @@ pub trait LuaSchedulerExt<'lua> { - Spawning background (`Send`) futures on the current executor - Spawning blocking tasks on a separate thread pool */ -pub trait LuaSpawnExt<'lua> { +pub trait LuaSpawnExt { /** Spawns the given future on the current executor and returns its [`Task`]. @@ -182,7 +182,7 @@ pub trait LuaSpawnExt<'lua> { })? )?; - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); sched.push_thread_front(lua.load("spawnBackgroundTask()"), ()); block_on(sched.run()); @@ -226,7 +226,7 @@ pub trait LuaSpawnExt<'lua> { })? )?; - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); sched.push_thread_front(lua.load("spawnLocalTask()"), ()); block_on(sched.run()); @@ -268,7 +268,7 @@ pub trait LuaSpawnExt<'lua> { })? )?; - let sched = Scheduler::new(&lua); + let sched = Scheduler::new(lua.clone()); sched.push_thread_front(lua.load("spawnBlockingTask()"), ()); block_on(sched.run()); @@ -282,7 +282,7 @@ pub trait LuaSpawnExt<'lua> { T: Send + 'static; } -impl<'lua> LuaSchedulerExt<'lua> for Lua { +impl LuaSchedulerExt for Lua { fn set_exit_code(&self, code: u8) { let exit = self .app_data_ref::() @@ -291,9 +291,9 @@ impl<'lua> LuaSchedulerExt<'lua> for Lua { } fn push_thread_front( - &'lua self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + &self, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult { let queue = self .app_data_ref::() @@ -302,9 +302,9 @@ impl<'lua> LuaSchedulerExt<'lua> for Lua { } fn push_thread_back( - &'lua self, - thread: impl IntoLuaThread<'lua>, - args: impl IntoLuaMulti<'lua>, + &self, + thread: impl IntoLuaThread, + args: impl IntoLuaMulti, ) -> LuaResult { let queue = self .app_data_ref::() @@ -312,21 +312,21 @@ impl<'lua> LuaSchedulerExt<'lua> for Lua { queue.push_item(self, thread, args) } - fn track_thread(&'lua self, id: ThreadId) { + fn track_thread(&self, id: ThreadId) { let map = self .app_data_ref::() .expect("lua threads can only be tracked from within an active scheduler"); map.track(id); } - fn get_thread_result(&'lua self, id: ThreadId) -> Option>> { + fn get_thread_result(&self, id: ThreadId) -> Option> { let map = self .app_data_ref::() .expect("lua threads results can only be retrieved from within an active scheduler"); map.remove(id).map(|r| r.value(self)) } - fn wait_for_thread(&'lua self, id: ThreadId) -> impl Future { + fn wait_for_thread(&self, id: ThreadId) -> impl Future { let map = self .app_data_ref::() .expect("lua threads results can only be retrieved from within an active scheduler"); @@ -334,7 +334,7 @@ impl<'lua> LuaSchedulerExt<'lua> for Lua { } } -impl LuaSpawnExt<'_> for Lua { +impl LuaSpawnExt for Lua { fn spawn(&self, fut: F) -> Task where F: Future + Send + 'static, diff --git a/crates/mlua-luau-scheduler/src/util.rs b/crates/mlua-luau-scheduler/src/util.rs index 2fe537b..8f6c188 100644 --- a/crates/mlua-luau-scheduler/src/util.rs +++ b/crates/mlua-luau-scheduler/src/util.rs @@ -10,10 +10,10 @@ use tracing::instrument; Otherwise returns the values yielded by the thread, or the error that caused it to stop. */ #[instrument(level = "trace", name = "Scheduler::run_until_yield", skip_all)] -pub(crate) async fn run_until_yield<'lua>( - thread: LuaThread<'lua>, - args: LuaMultiValue<'lua>, -) -> Option>> { +pub(crate) async fn run_until_yield( + thread: LuaThread, + args: LuaMultiValue, +) -> Option> { let mut stream = thread.into_async(args); /* NOTE: It is very important that we drop the thread/stream as @@ -83,11 +83,7 @@ pub(crate) struct ThreadWithArgs { } impl ThreadWithArgs { - pub fn new<'lua>( - lua: &'lua Lua, - thread: LuaThread<'lua>, - args: LuaMultiValue<'lua>, - ) -> LuaResult { + pub fn new(lua: &Lua, thread: LuaThread, args: LuaMultiValue) -> LuaResult { let argsv = args.into_vec(); let key_thread = lua.create_registry_value(thread)?; @@ -99,7 +95,7 @@ impl ThreadWithArgs { }) } - pub fn into_inner(self, lua: &Lua) -> (LuaThread<'_>, LuaMultiValue<'_>) { + pub fn into_inner(self, lua: &Lua) -> (LuaThread, LuaMultiValue) { let thread = lua.registry_value(&self.key_thread).unwrap(); let argsv = lua.registry_value(&self.key_args).unwrap(); @@ -118,13 +114,13 @@ impl ThreadWithArgs { [`LuaThreadOrFunction::into_thread`] may be used to convert the value into a Lua thread. */ #[derive(Clone)] -pub(crate) enum LuaThreadOrFunction<'lua> { - Thread(LuaThread<'lua>), - Function(LuaFunction<'lua>), +pub(crate) enum LuaThreadOrFunction { + Thread(LuaThread), + Function(LuaFunction), } -impl<'lua> LuaThreadOrFunction<'lua> { - pub(super) fn into_thread(self, lua: &'lua Lua) -> LuaResult> { +impl LuaThreadOrFunction { + pub(super) fn into_thread(self, lua: &Lua) -> LuaResult { match self { Self::Thread(t) => Ok(t), Self::Function(f) => lua.create_thread(f), @@ -132,14 +128,14 @@ impl<'lua> LuaThreadOrFunction<'lua> { } } -impl<'lua> FromLua<'lua> for LuaThreadOrFunction<'lua> { - fn from_lua(value: LuaValue<'lua>, _: &'lua Lua) -> LuaResult { +impl FromLua for LuaThreadOrFunction { + fn from_lua(value: LuaValue, _: &Lua) -> LuaResult { match value { LuaValue::Thread(t) => Ok(Self::Thread(t)), LuaValue::Function(f) => Ok(Self::Function(f)), value => Err(LuaError::FromLuaConversionError { from: value.type_name(), - to: "LuaThreadOrFunction", + to: "LuaThreadOrFunction".to_string(), message: Some("Expected thread or function".to_string()), }), }