Update Luau Compiler methods to better control extra options:

- Add `add_mutable_global`
- Add `add_userdata_type`
- Replace `set_library_constants` with `add_library_constant`
- Add `add_disabled_builtin`

Author: khvzak

src/chunk.rs

@@ -163,15 +163,36 @@ pub enum CompileConstant {
     String(String),
 }
 
-#[cfg(feature = "luau")]
-impl From<&'static str> for CompileConstant {
-    fn from(s: &'static str) -> Self {
-        CompileConstant::String(s.to_string())
+#[cfg(any(feature = "luau", doc))]
+impl From<bool> for CompileConstant {
+    fn from(b: bool) -> Self {
+        CompileConstant::Boolean(b)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<crate::Number> for CompileConstant {
+    fn from(n: crate::Number) -> Self {
+        CompileConstant::Number(n)
     }
 }
 
 #[cfg(any(feature = "luau", doc))]
-type LibraryMemberConstantMap = std::sync::Arc<HashMap<(String, String), CompileConstant>>;
+impl From<crate::Vector> for CompileConstant {
+    fn from(v: crate::Vector) -> Self {
+        CompileConstant::Vector(v)
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl From<&str> for CompileConstant {
+    fn from(s: &str) -> Self {
+        CompileConstant::String(s.to_owned())
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+type LibraryMemberConstantMap = HashMap<(String, String), CompileConstant>;
 
 /// Luau compiler
 #[cfg(any(feature = "luau", doc))]
@@ -288,49 +309,75 @@ impl Compiler {
         self
     }
 
+    /// Adds a mutable global.
+    ///
+    /// It disables the import optimization for fields accessed through it.
+    #[must_use]
+    pub fn add_mutable_global(mut self, global: impl Into<StdString>) -> Self {
+        self.mutable_globals.push(global.into());
+        self
+    }
+
     /// Sets a list of globals that are mutable.
     ///
     /// It disables the import optimization for fields accessed through these.
     #[must_use]
-    pub fn set_mutable_globals<S: Into<String>>(mut self, globals: Vec<S>) -> Self {
+    pub fn set_mutable_globals<S: Into<StdString>>(mut self, globals: impl IntoIterator<Item = S>) -> Self {
         self.mutable_globals = globals.into_iter().map(|s| s.into()).collect();
         self
     }
 
+    /// Adds a userdata type to the list that will be included in the type information.
+    #[must_use]
+    pub fn add_userdata_type(mut self, r#type: impl Into<StdString>) -> Self {
+        self.userdata_types.push(r#type.into());
+        self
+    }
+
     /// Sets a list of userdata types that will be included in the type information.
     #[must_use]
-    pub fn set_userdata_types<S: Into<String>>(mut self, types: Vec<S>) -> Self {
+    pub fn set_userdata_types<S: Into<StdString>>(mut self, types: impl IntoIterator<Item = S>) -> Self {
         self.userdata_types = types.into_iter().map(|s| s.into()).collect();
         self
     }
 
-    /// Sets constants for known library members.
+    /// Adds a constant for a known library member.
     ///
     /// The constants are used by the compiler to optimize the generated bytecode.
     /// Optimization level must be at least 2 for this to have any effect.
     ///
     /// The first element of the tuple is the library name,the second is the member name, and the
     /// third is the constant value.
     #[must_use]
-    pub fn set_library_constants<L, M>(mut self, constants: Vec<(L, M, CompileConstant)>) -> Self
-    where
-        L: Into<String>,
-        M: Into<String>,
-    {
-        let map = constants
-            .into_iter()
-            .map(|(lib, member, cons)| ((lib.into(), member.into()), cons))
-            .collect::<HashMap<_, _>>();
-        self.library_constants = Some(std::sync::Arc::new(map));
-        self.libraries_with_known_members = (self.library_constants.clone())
-            .map(|map| map.keys().map(|(lib, _)| lib.clone()).collect())
-            .unwrap_or_default();
+    pub fn add_library_constant(
+        mut self,
+        lib: impl Into<StdString>,
+        member: impl Into<StdString>,
+        r#const: impl Into<CompileConstant>,
+    ) -> Self {
+        let (lib, member) = (lib.into(), member.into());
+        if !self.libraries_with_known_members.contains(&lib) {
+            self.libraries_with_known_members.push(lib.clone());
+        }
+        self.library_constants
+            .get_or_insert_with(HashMap::new)
+            .insert((lib, member), r#const.into());
+        self
+    }
+
+    /// Adds a builtin that should be disabled.
+    #[must_use]
+    pub fn add_disabled_builtin(mut self, builtin: impl Into<StdString>) -> Self {
+        self.disabled_builtins.push(builtin.into());
         self
     }
 
     /// Sets a list of builtins that should be disabled.
     #[must_use]
-    pub fn set_disabled_builtins<S: Into<String>>(mut self, builtins: Vec<S>) -> Self {
+    pub fn set_disabled_builtins<S: Into<StdString>>(
+        mut self,
+        builtins: impl IntoIterator<Item = S>,
+    ) -> Self {
         self.disabled_builtins = builtins.into_iter().map(|s| s.into()).collect();
         self
     }

tests/chunk.rs

@@ -122,9 +122,9 @@ fn test_compiler() -> Result<()> {
         .set_vector_lib("vector")
         .set_vector_ctor("new")
         .set_vector_type("vector")
-        .set_mutable_globals(vec!["mutable_global"])
-        .set_userdata_types(vec!["MyUserdata"])
-        .set_disabled_builtins(vec!["tostring"]);
+        .set_mutable_globals(["mutable_global"])
+        .set_userdata_types(["MyUserdata"])
+        .set_disabled_builtins(["tostring"]);
 
     assert!(compiler.compile("return tostring(vector.new(1, 2, 3))").is_ok());
 
@@ -142,16 +142,14 @@ fn test_compiler() -> Result<()> {
 #[cfg(feature = "luau")]
 #[test]
 fn test_compiler_library_constants() {
-    use mlua::{CompileConstant, Compiler, Vector};
+    use mlua::{Compiler, Vector};
 
     let compiler = Compiler::new()
         .set_optimization_level(2)
-        .set_library_constants(vec![
-            ("mylib", "const_bool", CompileConstant::Boolean(true)),
-            ("mylib", "const_num", CompileConstant::Number(123.0)),
-            ("mylib", "const_vec", CompileConstant::Vector(Vector::zero())),
-            ("mylib", "const_str", "value1".into()),
-        ]);
+        .add_library_constant("mylib", "const_bool", true)
+        .add_library_constant("mylib", "const_num", 123.0)
+        .add_library_constant("mylib", "const_vec", Vector::zero())
+        .add_library_constant("mylib", "const_str", "value1");
 
     let lua = Lua::new();
     lua.set_compiler(compiler);