bump bevy api gen

maksymilian-mozolewski · maksymilian-mozolewski · commit ef60be3deac0 · 2024-12-22T15:35:11.000Z
diff --git a/crates/bevy_api_gen/Cargo.bootstrap.toml b/crates/bevy_api_gen/Cargo.bootstrap.toml
@@ -5,8 +5,8 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-mlua = { version = "0.9.2", features = ["lua54", "vendored", "send", "macros"] }
-bevy_reflect = { version = "0.15.0-rc.3", features = [
+mlua = { version = "0.10", features = ["lua54", "vendored", "send", "macros"] }
+bevy_reflect = { version = "0.15.0", features = [
     "bevy",
     "glam",
     "petgraph",
diff --git a/crates/bevy_api_gen/Cargo.toml b/crates/bevy_api_gen/Cargo.toml
@@ -39,7 +39,7 @@ rustc_private = true
 [dependencies]
 log = "0.4"
 env_logger = "0.11"
-rustc_plugin = { git = "https://github.com/makspll/rustc_plugin", branch = "feature/rust-1.82.0" }
+rustc_plugin = "0.12.0-nightly-2024-12-15"
 indexmap = "2"
 tempdir = "0.3"
 cargo_metadata = "0.18"
diff --git a/crates/bevy_api_gen/rust-toolchain.toml b/crates/bevy_api_gen/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
 components = ["clippy", "rust-src", "rustc-dev", "llvm-tools"]
-channel = "nightly-2024-11-05"
+channel = "nightly-2024-12-15"
diff --git a/crates/bevy_api_gen/src/callback.rs b/crates/bevy_api_gen/src/callback.rs
@@ -19,12 +19,10 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks {
     fn after_expansion<'tcx>(
         &mut self,
         compiler: &rustc_interface::interface::Compiler,
-        queries: &'tcx rustc_interface::Queries<'tcx>,
+        tcx: rustc_middle::ty::TyCtxt<'tcx>,
     ) -> rustc_driver::Compilation {
         trace!("After expansion callback");
-        let Ok(mut gcx) = queries.global_ctxt() else {
-            FatalError.raise()
-        };
+
         let sess = &compiler.sess;
 
         if sess.dcx().has_errors().is_some() {
@@ -59,37 +57,36 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks {
             _ => false,
         };
 
-        gcx.enter(|tcx| {
-            // tera environment for import processor
-            let tera = crate::configure_tera(tcx.crate_name(LOCAL_CRATE).as_str(), &templates_dir);
+        // tera environment for import processor
+        let tera = crate::configure_tera(tcx.crate_name(LOCAL_CRATE).as_str(), &templates_dir);
 
-            let mut ctxt = crate::BevyCtxt::new(
-                tcx,
-                &meta_dirs,
-                WorkspaceMeta::from_env(),
-                include_private,
-                Some(Box::new(move |import_path| {
-                    let mut ctxt = Context::new();
-                    ctxt.insert("import", import_path);
-                    tera.render(&TemplateKind::ImportProcessor.to_string(), &ctxt)
-                        .unwrap()
-                })),
-            );
+        let mut ctxt = crate::BevyCtxt::new(
+            tcx,
+            &meta_dirs,
+            WorkspaceMeta::from_env(),
+            include_private,
+            Some(Box::new(move |import_path| {
+                let mut ctxt = Context::new();
+                ctxt.insert("import", import_path);
+                tera.render(&TemplateKind::ImportProcessor.to_string(), &ctxt)
+                    .unwrap()
+            })),
+        );
 
-            trace!("Running all passes");
-            for p in ALL_PASSES {
-                info!(
-                    "{}, in crate: {}",
-                    p.description,
-                    tcx.crate_name(LOCAL_CRATE),
-                );
-                let continue_ = tcx.sess.time(p.name, || (p.cb)(&mut ctxt, &self.args));
-                if !continue_ {
-                    break;
-                }
-                trace!("Finished pass, continuing");
+        trace!("Running all passes");
+        for p in ALL_PASSES {
+            info!(
+                "{}, in crate: {}",
+                p.description,
+                tcx.crate_name(LOCAL_CRATE),
+            );
+            let continue_ = tcx.sess.time(p.name, || (p.cb)(&mut ctxt, &self.args));
+            if !continue_ {
+                break;
             }
-        });
+            trace!("Finished pass, continuing");
+        }
+
         rustc_driver::Compilation::Continue
     }
 }
diff --git a/crates/bevy_api_gen/src/passes/find_methods_and_fields.rs b/crates/bevy_api_gen/src/passes/find_methods_and_fields.rs
@@ -7,7 +7,7 @@ use rustc_hir::{
 };
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::ty::{
-    AdtKind, AssocKind, FieldDef, FnSig, ParamEnv, Ty, TyCtxt, TyKind, TypingMode,
+    AdtKind, AssocKind, FieldDef, FnSig, ParamEnv, Ty, TyCtxt, TyKind, TypingEnv, TypingMode,
 };
 use rustc_span::Symbol;
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -36,8 +36,8 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) ->
                         info!("ignoring enum variant: {}::{} due to 'reflect(ignore)' attribute", ctxt.tcx.item_name(def_id), variant.name);
                         todo!();
                     }
-
-                    process_fields(ctxt.tcx, &ctxt.meta_loader, &ctxt.reflect_types, &ctxt.cached_traits, variant.fields.iter(), ctxt.tcx.param_env(variant.def_id))
+                    let param_env = TypingEnv::non_body_analysis(ctxt.tcx, variant.def_id);
+                    process_fields(ctxt.tcx, &ctxt.meta_loader, &ctxt.reflect_types, &ctxt.cached_traits, variant.fields.iter(), param_env)
                 }).collect::<Vec<_>>();
 
                 strats.iter().for_each(|(f_did, strat)| match strat {
@@ -52,7 +52,8 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) ->
 
             },
             AdtKind::Struct => {
-                let fields = process_fields(ctxt.tcx, &ctxt.meta_loader, &ctxt.reflect_types,&ctxt.cached_traits, adt_def.all_fields(), ctxt.tcx.param_env(def_id));
+                let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id);
+                let fields = process_fields(ctxt.tcx, &ctxt.meta_loader, &ctxt.reflect_types,&ctxt.cached_traits, adt_def.all_fields(), param_env);
                 fields.iter().for_each(|(f_did, strat)| match strat {
                     ReflectionStrategy::Reflection => report_field_not_supported(ctxt.tcx, *f_did, def_id, None, "type is neither a proxy nor a type expressible as lua primitive"),
                     ReflectionStrategy::Filtered => report_field_not_supported(ctxt.tcx, *f_did, def_id, None, "field has a 'reflect(ignore)' attribute"),
@@ -118,7 +119,8 @@ pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) ->
                         ctxt.tcx.item_name(def_id)
                     );
 
-                    let param_env = ctxt.tcx.param_env(fn_did);
+                    // let param_env = ctxt.tcx.param_env(fn_did);
+                    let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id);
                     let sig: FnSig = ctxt.tcx.normalize_erasing_late_bound_regions(
                         param_env,
                         ctxt.tcx.fn_sig(fn_did).instantiate_identity(),
@@ -238,10 +240,9 @@ fn report_field_not_supported(
     variant_did: Option<DefId>,
     reason: &'static str,
 ) {
-    let normalised_ty = tcx.normalize_erasing_regions(
-        tcx.param_env(type_did),
-        tcx.type_of(f_did).instantiate_identity(),
-    );
+    let param_env = TypingEnv::non_body_analysis(tcx, type_did);
+    let normalised_ty =
+        tcx.normalize_erasing_regions(param_env, tcx.type_of(f_did).instantiate_identity());
     info!(
         "Ignoring field: `{}:{}` on type: `{}` in variant: `{}` as it is not supported: `{}`",
         tcx.item_name(f_did),
@@ -259,7 +260,7 @@ fn process_fields<'tcx, 'f, I: Iterator<Item = &'f FieldDef>>(
     reflect_types: &IndexMap<DefId, ReflectType<'tcx>>,
     cached_traits: &CachedTraits,
     fields: I,
-    param_env: ParamEnv<'tcx>,
+    param_env: TypingEnv<'tcx>,
 ) -> Vec<(DefId, ReflectionStrategy)> {
     fields
         .map(move |f| {
@@ -364,7 +365,7 @@ fn type_is_adt_and_reflectable<'tcx>(
 /// Checks if the type can be used directly as a lua function argument, by checking if it implements the FromLua trait
 fn type_is_supported_as_non_proxy_arg<'tcx>(
     tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
+    param_env: TypingEnv<'tcx>,
     cached_traits: &CachedTraits,
     ty: Ty<'tcx>,
 ) -> bool {
@@ -380,7 +381,7 @@ fn type_is_supported_as_non_proxy_arg<'tcx>(
 /// Checks if the type can be used directly as a lua function output
 fn type_is_supported_as_non_proxy_return_val<'tcx>(
     tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
+    param_env: TypingEnv<'tcx>,
     cached_traits: &CachedTraits,
     ty: Ty<'tcx>,
 ) -> bool {
@@ -401,12 +402,12 @@ fn type_is_supported_as_non_proxy_return_val<'tcx>(
 
 pub(crate) fn impls_trait<'tcx>(
     tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
+    param_env: TypingEnv<'tcx>,
     ty: Ty<'tcx>,
     trait_did: DefId,
 ) -> bool {
     tcx.infer_ctxt()
-        .build(TypingMode::non_body_analysis())
-        .type_implements_trait(trait_did, [ty], param_env)
+        .build(param_env.typing_mode)
+        .type_implements_trait(trait_did, [ty], param_env.param_env)
         .must_apply_modulo_regions()
 }
diff --git a/crates/bevy_api_gen/src/passes/find_trait_impls.rs b/crates/bevy_api_gen/src/passes/find_trait_impls.rs
@@ -6,9 +6,9 @@ use rustc_infer::{
     infer::{InferCtxt, TyCtxtInferExt},
     traits::{Obligation, ObligationCause},
 };
-use rustc_middle::ty::{Ty, TypingMode};
+use rustc_middle::ty::{Ty, TypingEnv, TypingMode};
 use rustc_span::DUMMY_SP;
-use rustc_trait_selection::traits::ObligationCtxt;
+use rustc_trait_selection::{regions::InferCtxtRegionExt, traits::ObligationCtxt};
 
 use crate::{Args, BevyCtxt};
 
@@ -134,7 +134,10 @@ fn impl_matches<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, impl_def_id: DefId)
 
     let impl_may_apply = |impl_def_id| {
         let ocx = ObligationCtxt::new(infcx);
-        let param_env = tcx.param_env_reveal_all_normalized(impl_def_id);
+        // let param_env = infcx.resolve_regions(impl_def_id);
+        // let param_env = tcx.param_env_reveal_all_normalized(impl_def_id);
+        let typing_env = TypingEnv::non_body_analysis(tcx, impl_def_id);
+        let param_env = typing_env.with_post_analysis_normalized(tcx).param_env;
         let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
 
         let impl_trait_ref = tcx
diff --git a/crates/bevy_api_gen/src/passes/populate_template_data.rs b/crates/bevy_api_gen/src/passes/populate_template_data.rs
@@ -5,7 +5,7 @@ use rustc_ast::Attribute;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE};
 use rustc_middle::ty::{
     print::Print, AdtDef, FieldDef, GenericArg, GenericParamDefKind, ParamTy, TraitRef, Ty, TyKind,
-    TypeFoldable,
+    TypeFoldable, TypingEnv,
 };
 use rustc_span::Symbol;
 
@@ -148,9 +148,10 @@ pub(crate) fn process_functions(ctxt: &BevyCtxt, fns: &[FunctionContext]) -> Vec
                 .zip(fn_sig.inputs())
                 .enumerate()
                 .map(|(idx, (ident, ty))| {
-                    let normalized_ty = ctxt
-                        .tcx
-                        .normalize_erasing_regions(ctxt.tcx.param_env(fn_ctxt.def_id), *ty);
+                    let normalized_ty = ctxt.tcx.normalize_erasing_regions(
+                        TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id),
+                        *ty,
+                    );
                     Arg {
                         ident: ident.to_string(),
                         ty: ty_to_string(ctxt, normalized_ty, false),
@@ -160,9 +161,10 @@ pub(crate) fn process_functions(ctxt: &BevyCtxt, fns: &[FunctionContext]) -> Vec
                 })
                 .collect();
 
-            let out_ty = ctxt
-                .tcx
-                .normalize_erasing_regions(ctxt.tcx.param_env(fn_ctxt.def_id), fn_sig.output());
+            let out_ty = ctxt.tcx.normalize_erasing_regions(
+                TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id),
+                fn_sig.output(),
+            );
 
             let output = Output {
                 ty: ty_to_string(ctxt, out_ty, false),
@@ -288,16 +290,14 @@ pub(crate) enum ProxyType {
     Ref,
     RefMut,
     Val,
-    NonReflectVal,
 }
 
 impl ProxyType {
     pub fn to_ident_str(self) -> &'static str {
         match self {
-            ProxyType::Ref => "LuaReflectRefProxy",
-            ProxyType::RefMut => "LuaReflectRefMutProxy",
-            ProxyType::Val => "LuaReflectValProxy",
-            ProxyType::NonReflectVal => "LuaValProxy",
+            ProxyType::Ref => "Ref",
+            ProxyType::RefMut => "Mut",
+            ProxyType::Val => "Val",
         }
     }
 }
diff --git a/crates/bevy_api_gen/src/plugin.rs b/crates/bevy_api_gen/src/plugin.rs
@@ -1,9 +1,9 @@
+use std::env;
+
 use clap::Parser;
 use log::debug;
 use rustc_plugin::{CrateFilter, RustcPlugin, RustcPluginArgs, Utf8Path};
 
-use std::env;
-
 use crate::{modifying_file_loader::ModifyingFileLoader, BevyAnalyzerCallbacks, WorkspaceMeta};
 
 pub struct BevyAnalyzer;
@@ -47,15 +47,16 @@ impl RustcPlugin for BevyAnalyzer {
 
                 struct DefaultCallbacks;
                 impl rustc_driver::Callbacks for DefaultCallbacks {}
-                return rustc_driver::RunCompiler::new(&compiler_args, &mut DefaultCallbacks).run();
+                rustc_driver::RunCompiler::new(&compiler_args, &mut DefaultCallbacks).run();
+                return Ok(());
             }
         }
         let mut callbacks = BevyAnalyzerCallbacks::new(plugin_args);
         let mut compiler = rustc_driver::RunCompiler::new(&compiler_args, &mut callbacks);
         compiler.set_file_loader(Some(Box::new(ModifyingFileLoader)));
         let out = compiler.run();
         log::trace!("Finished compiling with plugin");
-        out
+        Ok(())
     }
 
     fn modify_cargo(&self, cmd: &mut std::process::Command, args: &Self::Args) {
diff --git a/makefile b/makefile
@@ -21,21 +21,21 @@ PACKAGE=bevy_mod_scripting
 TEST_NAME=
 # # valgrind outputs a callgrind.out.<pid>. We can analyze this with kcachegrind
 # kcachegrind
-NIGHTLY_VERSION=nightly-2024-11-05
+NIGHTLY_VERSION=nightly-2024-12-15
 BEVY_VERSION=0.15.0
 GLAM_VERSION=0.29.0
 CODEGEN_PATH=${PWD}/target/codegen
 BEVY_PATH=${CODEGEN_PATH}/bevy
 GLAM_PATH=${CODEGEN_PATH}/glam
 OUTPUT_PATH=${CODEGEN_PATH}/output
-GENERATED_SRC_PATH=./crates/languages/bevy_mod_scripting_lua/src/bindings/providers
+GENERATED_SRC_PATH=./crates/bevy_mod_scripting_functions/src/bevy/
 GEN_BEVY_FEATURES=bevy_asset,bevy_animation,bevy_core_pipeline,bevy_ui,bevy_pbr,bevy_render,bevy_text,bevy_sprite,file_watcher,multi_threaded
 
 build_test_in_package:
 	@RUSTFLAGS=-g cargo test --no-run  --all-targets --features ${TEST_FEATURES} --package ${PACKAGE} $(TEST_NAME) --message-format=json | jq -r 'first(select(.executable != null and .target.kind == ["test"])) | .executable' | xargs -I@ ln -fs @ ./target/debug/test_binary
 
 run_lua_tests:
-	cargo test --features=lua54 --package bevy_mod_scripting_lua --test lua_tests
+	cargo test --features=lua54 --package bevy_mod_scripting_lua --test lua_tests -- $(TEST_NAME)
 
 
 comp_benches:
@@ -63,7 +63,7 @@ clean_bevy:
 	cd ${BEVY_PATH} && cargo clean
 
 generate_bevy:
-	cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen generate --output ${OUTPUT_PATH} --template-args '{ "self_is_bms_lua": true}' --features ${GEN_BEVY_FEATURES}
+	cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen generate --output ${OUTPUT_PATH} --template-args '{ "self_is_bms_lua": true}' --features ${GEN_BEVY_FEATURES} -vv
 
 collect_bevy:
 	cd ${BEVY_PATH} && cargo +${NIGHTLY_VERSION} bevy-api-gen collect --output ${OUTPUT_PATH} --template-args '{ "self_is_bms_lua": true}'
