fix bug causing incomplete codegen

Author: makspll

crates/bevy_api_gen/Cargo.toml

@@ -54,6 +54,7 @@ convert_case = "0.6"
 syn = { version = "2", features = ["parsing"], no-default-features = true }
 clap-verbosity-flag = "2.2"
 itertools = "0.12"
+chrono = "0.4"
 
 [build-dependencies]
 toml = "0.8"

crates/bevy_api_gen/src/bin/driver.rs

@@ -2,6 +2,8 @@
 use bevy_api_gen::*;
 
 fn main() {
+    // initially set it to high so no logs are missed, but later when we parse the args we will set it to the correct level
+    std::env::set_var("RUST_LOG", "trace");
     env_logger::init();
     rustc_plugin::driver_main(BevyAnalyzer);
 }

crates/bevy_api_gen/src/bin/main.rs

@@ -26,6 +26,8 @@ fn main() {
     }
     env_logger::init();
 
+    info!("Using RUST_LOG: {:?}", env::var("RUST_LOG"));
+
     info!("Computing crate metadata");
     let metadata = cargo_metadata::MetadataCommand::new()
         .no_deps()

crates/bevy_api_gen/src/callback.rs

@@ -59,6 +59,7 @@ impl rustc_driver::Callbacks for BevyAnalyzerCallbacks {
         // tera environment for import processor
         let tera = crate::configure_tera(tcx.crate_name(LOCAL_CRATE).as_str(), &templates_dir);
 
+        info!("Using meta directories: {:?}", meta_dirs);
         let mut ctxt = crate::BevyCtxt::new(
             tcx,
             &meta_dirs,

crates/bevy_api_gen/src/meta.rs

@@ -6,9 +6,10 @@ use std::{
 };
 
 use cargo_metadata::camino::Utf8PathBuf;
+use chrono::NaiveDateTime;
 use log::trace;
 use rustc_hir::def_id::DefPathHash;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize, Serializer};
 
 use crate::WorkspaceMeta;
 
@@ -25,6 +26,27 @@ pub struct Meta {
     /// False if no files are going to be generated for this crate
     pub(crate) will_generate: bool,
     pub(crate) meta_version: String,
+    #[serde(
+        serialize_with = "serialize_timestamp",
+        deserialize_with = "deserialize_timestamp"
+    )]
+    pub(crate) timestamp: NaiveDateTime,
+}
+
+fn serialize_timestamp<S: Serializer>(
+    timestamp: &NaiveDateTime,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
+    // format as date and time
+    serializer.serialize_str(&timestamp.format("%Y-%m-%d %H:%M:%S").to_string())
+}
+
+fn deserialize_timestamp<'de, D>(deserializer: D) -> Result<NaiveDateTime, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let s = String::deserialize(deserializer)?;
+    NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S").map_err(serde::de::Error::custom)
 }
 
 impl Meta {
@@ -37,7 +59,7 @@ impl Meta {
     }
 }
 
-#[derive(Serialize, Deserialize, Clone)]
+#[derive(Serialize, Deserialize, Clone, Debug)]
 pub(crate) struct ProxyMeta {
     pub(crate) ident: String,
     pub(crate) stable_crate_id: u64,
@@ -46,8 +68,8 @@ pub(crate) struct ProxyMeta {
 
 /// Manages deserialisation and retrieval of meta files
 pub struct MetaLoader {
-    pub(crate) meta_dirs: Vec<Utf8PathBuf>,
-    pub(crate) workspace_meta: WorkspaceMeta,
+    pub meta_dirs: Vec<Utf8PathBuf>,
+    pub workspace_meta: WorkspaceMeta,
     cache: RefCell<HashMap<String, Meta>>,
 }
 
@@ -78,7 +100,7 @@ impl MetaLoader {
     ) -> bool {
         let meta = match meta_sources
             .iter()
-            .filter(|s| curr_source.is_none() || curr_source.is_some_and(|cs| cs == **s))
+            .filter(|s| curr_source.is_none() || curr_source.is_some_and(|cs| cs != **s))
             .find_map(|s| self.meta_for(s))
         {
             Some(meta) => meta,
@@ -100,7 +122,7 @@ impl MetaLoader {
 
         if meta.is_none() {
             log::trace!(
-                "Could not find meta for crate: `{}`, is_workspace_and_included: '{}'",
+                "Could not find meta file for crate: `{}`, is_workspace_and_included: '{}'",
                 crate_name,
                 needs_meta
             )
@@ -118,11 +140,15 @@ impl MetaLoader {
             trace!("Loading meta from cache for: {}", crate_name);
             cache.get(crate_name).cloned()
         } else {
-            trace!("Loading meta from filesystem for: {}", crate_name);
             drop(cache);
             let mut cache = self.cache.borrow_mut();
-            let meta =
-                Self::opt_load_meta(dir.join(Self::crate_name_to_meta_filename(crate_name)))?;
+            let dir = dir.join(Self::crate_name_to_meta_filename(crate_name));
+            trace!(
+                "Attempting to load meta from filesystem for crate: {}, at: {}",
+                crate_name,
+                dir
+            );
+            let meta = Self::opt_load_meta(dir)?;
             cache.insert(crate_name.to_owned(), meta.clone());
             Some(meta)
         }
@@ -150,7 +176,7 @@ impl MetaLoader {
 
         let file = File::create(&path).unwrap();
         let mut writer = BufWriter::new(file);
-        serde_json::to_writer(&mut writer, meta).unwrap();
+        serde_json::to_writer_pretty(&mut writer, meta).unwrap();
         writer.flush().expect("Could not flush data to meta file");
     }
 

crates/bevy_api_gen/src/passes/find_methods_and_fields.rs

@@ -350,11 +350,19 @@ fn type_is_adt_and_reflectable<'tcx>(
             tcx.def_path_hash(did),
         );
 
-        log::trace!(
-            "Meta for type: `{}`, contained in meta `{}`",
-            tcx.item_name(did),
-            contains_hash
-        );
+        if contains_hash {
+            log::info!(
+                "Meta for type: `{}` with hash: `{:?}`, contained in the meta file",
+                tcx.item_name(did),
+                tcx.def_path_hash(did),
+            );
+        } else {
+            log::info!(
+                "Meta for type: `{}` with hash: `{:?}`, was not found in meta files for {crate_name} or in bevy_reflect, meaning it will not generate a proxy.",
+                tcx.item_name(did),
+                tcx.def_path_hash(did),
+            );
+        }
 
         contains_hash
     })

crates/bevy_api_gen/src/passes/populate_template_data.rs

@@ -125,10 +125,6 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo
     }
 
     trace!("Populated template context:");
-    trace!(
-        "{}",
-        serde_json::to_string_pretty(&ctxt.template_context).unwrap()
-    );
 
     true
 }
@@ -242,11 +238,15 @@ fn ty_to_string<'tcx>(ctxt: &BevyCtxt<'tcx>, ty: Ty<'tcx>, proxy_types: bool) ->
                         "bevy_reflect",
                     ];
 
-                    ctxt.meta_loader.one_of_meta_files_contains(
+                    trace!("Checking ADT: `{}`.", ctxt.tcx.item_name(def_id),);
+
+                    let contains = ctxt.meta_loader.one_of_meta_files_contains(
                         &meta_sources,
-                        Some(&ctxt.tcx.crate_name(LOCAL_CRATE).to_ident_string()),
+                        None,
                         def_path_hash,
-                    )
+                    );
+
+                    contains
                 })
                 .is_some_and(identity)
         }),
@@ -338,7 +338,6 @@ impl<'a> TyPrinter<'a> {
     }
 
     pub fn print(mut self, ty: Ty<'_>) -> String {
-        log::trace!("Printing type: {:#?}", ty);
         self.print_ty(ty);
         self.buffer
     }
@@ -369,16 +368,13 @@ impl<'a> TyPrinter<'a> {
     }
 
     fn print_adt<'tcx, I: Iterator<Item = GenericArg<'tcx>>>(&mut self, ty: AdtDef<'tcx>, args: I) {
-        log::trace!("Printing ADT: {:#?}", ty);
         let did = ty.did();
         let import_path = (self.path_finder)(did);
         self.buffer.push_str(&import_path);
         self.print_args(args);
     }
 
     fn print_ty(&mut self, ty: Ty<'_>) {
-        log::trace!("Printing type: {:#?}", ty);
-
         match ty.kind() {
             TyKind::Bool => self.print_literal("bool"),
             TyKind::Char => self.print_literal("char"),

crates/bevy_api_gen/src/passes/write_meta.rs

@@ -20,6 +20,7 @@ pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
         proxies,
         will_generate,
         meta_version: META_VERSION.to_string(),
+        timestamp: chrono::Local::now().naive_local(),
     };
 
     ctxt.meta_loader

crates/bevy_api_gen/src/plugin.rs

@@ -32,6 +32,8 @@ impl RustcPlugin for BevyAnalyzer {
         compiler_args: Vec<String>,
         plugin_args: Self::Args,
     ) -> rustc_interface::interface::Result<()> {
+        log::set_max_level(plugin_args.verbose.get_log_level().to_level_filter());
+
         if let Some(includes) = WorkspaceMeta::from_env().include_crates {
             let crate_name = compiler_args
                 .iter()

crates/bevy_mod_scripting_functions/src/bevy_bindings/bevy_hierarchy.rs

@@ -57,6 +57,16 @@ impl ::bevy::app::Plugin for BevyHierarchyScriptingPlugin {
                         .into();
                     output
                 },
+            )
+            .register(
+                "get",
+                |_self: Ref<bevy::hierarchy::prelude::Parent>| {
+                    let output: Val<bevy::ecs::entity::Entity> = bevy::hierarchy::prelude::Parent::get(
+                            &_self,
+                        )
+                        .into();
+                    output
+                },
             );
         NamespaceBuilder::<::bevy::hierarchy::HierarchyEvent>::new(world)
             .register(