remove mlua references from codegen

Author: makspll

crates/bevy_api_gen/Cargo.bootstrap.toml

@@ -1,11 +1,10 @@
-# Cargo.toml file used for bootstrapping of mlua and other dependencies which need to be included in every crate for analysis
+# Cargo.toml file used for bootstrapping of bms and other dependencies which need to be included in every crate for analysis
 [package]
 name = "bevy_analyzer_deps_bootstrap"
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-mlua = { version = "0.10", features = ["lua54", "vendored", "send", "macros"] }
 bevy_mod_scripting_core = { path = "{{BMS_CORE_PATH}}" }
 bevy_reflect = { version = "0.15.0", features = [
     "bevy",

crates/bevy_api_gen/src/bin/main.rs

@@ -15,7 +15,7 @@ use log::{debug, error, info};
 use strum::VariantNames;
 use tera::Context;
 
-const BOOTSTRAP_DEPS: [&str; 3] = ["mlua", "bevy_reflect", "bevy_mod_scripting_core"];
+const BOOTSTRAP_DEPS: [&str; 2] = ["bevy_reflect", "bevy_mod_scripting_core"];
 
 fn main() {
     // parse this here to early exit on wrong args

crates/bevy_api_gen/src/context.rs

@@ -90,8 +90,6 @@ pub(crate) const DEF_PATHS_BMS_INTO_SCRIPT: [&str; 2] = [
     "bindings::function::into::IntoScript",
 ];
 
-pub(crate) const DEF_PATHS_FROM_LUA: [&str; 2] = ["value::FromLuaMulti", "mlua::FromLuaMulti"];
-pub(crate) const DEF_PATHS_INTO_LUA: [&str; 2] = ["value::IntoLuaMulti", "mlua::IntoLuaMulti"];
 pub(crate) const DEF_PATHS_REFLECT: [&str; 2] =
     ["bevy_reflect::PartialReflect", "reflect::PartialReflect"];
 pub(crate) const DEF_PATHS_GET_TYPE_REGISTRATION: [&str; 2] = [
@@ -124,8 +122,6 @@ pub(crate) const STD_SOURCE_TRAITS: [&str; 14] = [
 /// A collection of common traits stored for quick access.
 #[derive(Default)]
 pub(crate) struct CachedTraits {
-    pub(crate) mlua_from_lua_multi: Option<DefId>,
-    pub(crate) mlua_into_lua_multi: Option<DefId>,
     pub(crate) bms_into_script: Option<DefId>,
     pub(crate) bms_from_script: Option<DefId>,
     pub(crate) bevy_reflect_reflect: Option<DefId>,
@@ -140,10 +136,6 @@ impl CachedTraits {
         self.bms_into_script.is_some() && self.bms_from_script.is_some()
     }
 
-    pub(crate) fn has_all_mlua_traits(&self) -> bool {
-        self.mlua_from_lua_multi.is_some() && self.mlua_into_lua_multi.is_some()
-    }
-
     pub(crate) fn has_all_bevy_traits(&self) -> bool {
         self.bevy_reflect_reflect.is_some() && self.bevy_reflect_get_type_registration.is_some()
     }

crates/bevy_api_gen/src/modifying_file_loader.rs

@@ -28,7 +28,7 @@ impl FileLoader for ModifyingFileLoader {
             RealFileLoader.read_file(path).map(|mut f| {
                 // we make it pub so in case we are re-exporting this crate we won't run into private re-export issues
 
-                for crate_ in &["bevy_reflect", "mlua", "bevy_mod_scripting_core"] {
+                for crate_ in &["bevy_reflect", "bevy_mod_scripting_core"] {
                     if !f.contains(&format!("extern crate {crate_}")) {
                         if f.contains(&format!("pub use {crate_}")) {
                             f.push_str(&format!(

crates/bevy_api_gen/src/passes/cache_traits.rs

@@ -3,8 +3,8 @@ use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_span::Symbol;
 
 use crate::{
-    Args, BevyCtxt, DEF_PATHS_BMS_FROM_SCRIPT, DEF_PATHS_BMS_INTO_SCRIPT, DEF_PATHS_FROM_LUA,
-    DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_INTO_LUA, DEF_PATHS_REFLECT, STD_SOURCE_TRAITS,
+    Args, BevyCtxt, DEF_PATHS_BMS_FROM_SCRIPT, DEF_PATHS_BMS_INTO_SCRIPT,
+    DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_REFLECT, STD_SOURCE_TRAITS,
 };
 
 /// Finds and caches relevant traits, if they cannot be found throws an ICE
@@ -13,13 +13,7 @@ pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
 
     for trait_did in tcx.all_traits() {
         let def_path_str = tcx.def_path_str(trait_did);
-        if DEF_PATHS_FROM_LUA.contains(&def_path_str.as_str()) {
-            trace!("found FromLuaMulti trait def id: {trait_did:?}");
-            ctxt.cached_traits.mlua_from_lua_multi = Some(trait_did);
-        } else if DEF_PATHS_INTO_LUA.contains(&def_path_str.as_str()) {
-            trace!("found ToLuaMulti trait def id: {trait_did:?}");
-            ctxt.cached_traits.mlua_into_lua_multi = Some(trait_did);
-        } else if DEF_PATHS_REFLECT.contains(&def_path_str.as_str()) {
+        if DEF_PATHS_REFLECT.contains(&def_path_str.as_str()) {
             trace!("found Reflect trait def id: {trait_did:?}");
             ctxt.cached_traits.bevy_reflect_reflect = Some(trait_did);
         } else if DEF_PATHS_GET_TYPE_REGISTRATION.contains(&def_path_str.as_str()) {
@@ -46,13 +40,6 @@ pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
         )
     }
 
-    if !ctxt.cached_traits.has_all_mlua_traits() {
-        panic!(
-            "Could not find all mlua traits in crate: {}, did bootstrapping go wrong?",
-            tcx.crate_name(LOCAL_CRATE)
-        )
-    }
-
     if !ctxt.cached_traits.has_all_bevy_traits() {
         panic!(
             "Could not find all reflect traits in crate: {}, did bootstrapping go wrong?",

crates/bevy_api_gen/src/passes/find_methods_and_fields.rs

@@ -376,12 +376,7 @@ fn type_is_supported_as_non_proxy_arg<'tcx>(
     ty: Ty<'tcx>,
 ) -> bool {
     trace!("Checking type is supported as non proxy arg: '{ty:?}' with param_env: '{param_env:?}'");
-    impls_trait(
-        tcx,
-        param_env,
-        ty,
-        cached_traits.mlua_from_lua_multi.unwrap(),
-    )
+    impls_trait(tcx, param_env, ty, cached_traits.bms_from_script.unwrap())
 }
 
 /// Checks if the type can be used directly as a lua function output
@@ -398,12 +393,7 @@ fn type_is_supported_as_non_proxy_return_val<'tcx>(
         }
     }
 
-    impls_trait(
-        tcx,
-        param_env,
-        ty,
-        cached_traits.mlua_into_lua_multi.unwrap(),
-    )
+    impls_trait(tcx, param_env, ty, cached_traits.bms_into_script.unwrap())
 }
 
 pub(crate) fn impls_trait<'tcx>(

crates/bevy_api_gen/src/passes/find_trait_impls.rs

@@ -33,13 +33,13 @@ pub(crate) fn find_trait_impls(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
         // filter out types which have impls both ways
         let retaining = type_impl_of_trait(
             tcx,
-            ctxt.cached_traits.mlua_from_lua_multi.unwrap(),
+            ctxt.cached_traits.bms_from_script.unwrap(),
             reflect_ty_did,
         )
         .is_empty()
             || type_impl_of_trait(
                 tcx,
-                ctxt.cached_traits.mlua_into_lua_multi.unwrap(),
+                ctxt.cached_traits.bms_into_script.unwrap(),
                 reflect_ty_did,
             )
             .is_empty();

crates/bevy_api_gen/src/passes/write_meta.rs

@@ -2,7 +2,7 @@ use rustc_hir::def_id::LOCAL_CRATE;
 
 use crate::{Args, BevyCtxt, Meta, ProxyMeta, META_VERSION};
 
-/// Finds and caches relevant mlua traits, if they cannot be found throws an ICE
+/// Finds and caches relevant traits, if they cannot be found throws an ICE
 pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
     let tcx = &ctxt.tcx;