diff --git a/.github/workflows/synchronize_bindings.yml b/.github/workflows/synchronize_bindings.yml
index aaaa55ff19..4c0ba2ee6c 100644
--- a/.github/workflows/synchronize_bindings.yml
+++ b/.github/workflows/synchronize_bindings.yml
@@ -32,7 +32,7 @@ jobs:
run: |
if [[ -n $(git status --porcelain) ]]; then
echo "changes=true" >> "$GITHUB_OUTPUT"
- git diff > bindings.diff
+ git diff --text > bindings.diff
echo "Diff created:"
cat bindings.diff
else
diff --git a/.github/workflows/synchronize_bindings_check_diff.yml b/.github/workflows/synchronize_bindings_check_diff.yml
index aebef0fdb2..7d2cd2f521 100644
--- a/.github/workflows/synchronize_bindings_check_diff.yml
+++ b/.github/workflows/synchronize_bindings_check_diff.yml
@@ -15,8 +15,9 @@ jobs:
env:
DIFF_ARTIFACT: bindings.diff
PR_EVENT: event-bindings.json
+ EVENT_FILE: event.json
steps:
- - name: Download Benchmark Results
+ - name: Download Diff Results
uses: dawidd6/action-download-artifact@v6
with:
name: ${{ env.DIFF_ARTIFACT }}
@@ -31,13 +32,48 @@ jobs:
with:
script: |
let fs = require('fs');
- let prEvent = JSON.parse(fs.readFileSync(process.env.PR_EVENT, {encoding: 'utf8'}));
+ let prEvent = JSON.parse(fs.readFileSync(process.env.EVENT_FILE, {encoding: 'utf8'}));
core.exportVariable("PR_HEAD", prEvent.pull_request.head.ref);
core.exportVariable("PR_BASE", prEvent.pull_request.base.ref);
core.exportVariable("PR_BASE_SHA", prEvent.pull_request.base.sha);
core.exportVariable("PR_NUMBER", prEvent.number);
core.exportVariable("HEAD_REPO", prEvent.pull_request.head.repo.full_name);
core.exportVariable("HEAD_REPO_URL", prEvent.pull_request.head.repo.git_url);
+
+ - name: Build Collapsible Diff Comment
+ id: build_comment
+ continue-on-error: true
+ shell: bash
+ run: |
+ echo '### 🔍 Binding Differences Detected' > comment.md
+ echo '' >> comment.md
+ echo '> The following changes were detected in generated bindings:' >> comment.md
+ echo '' >> comment.md
+
+ # Build collapsible sections per file
+ awk '
+ /^diff --git/ {
+ if (file != "") print "" >> "comment.md"
+ file=$4
+ gsub(/^a\//, "", file)
+ print "" file "
" >> "comment.md"
+ next
+ }
+ { print $0 >> "comment.md" }
+ END { if (file != "") print "- ;
+ fn friendly_name<'a, 'tcx>(&'a self, tcx: TyCtxt<'tcx>) -> Cow<'a, str>
+ where
+ 'tcx: 'a;
+}
+
+impl Annotated for GenerationCandidate<'_, D> {
+ fn with_note(mut self, note: GenerationExclusionNote) -> Self {
+ self.notes.push(note);
+ self
+ }
+
+ fn applying_notes(&self) -> impl Iterator
- {
+ self.notes
+ .iter()
+ .chain(self.variants.iter().flat_map(|v| v.applying_notes()))
+ .chain(
+ self.excluded_variants
+ .iter()
+ .flat_map(|v| v.applying_notes()),
+ )
+ .chain(self.functions.iter().flat_map(|f| f.applying_notes()))
+ .chain(
+ self.excluded_functions
+ .iter()
+ .flat_map(|f| f.applying_notes()),
+ )
+ }
+ fn friendly_name<'a, 'tcx>(&'a self, tcx: TyCtxt<'tcx>) -> Cow<'a, str>
+ where
+ 'tcx: 'a,
+ {
+ self.did
+ .map(|did| format!("{}::{}", tcx.crate_name(did.krate), tcx.item_name(did)).into())
+ .unwrap_or(Cow::Borrowed("unknown"))
+ }
+}
+
+impl Annotated for VariantCandidate<'_> {
+ fn with_note(mut self, note: GenerationExclusionNote) -> Self {
+ self.notes.push(note);
+ self
+ }
+
+ fn applying_notes(&self) -> impl Iterator
- {
+ self.notes
+ .iter()
+ .chain(self.fields.iter().flat_map(|f| f.applying_notes()))
+ .chain(self.excluded_fields.iter().flat_map(|f| f.applying_notes()))
+ }
+
+ fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str>
+ where
+ 'tcx: 'a,
+ {
+ self.def.name.as_str().into()
+ }
+}
+
+impl Annotated for FieldCandidate {
+ fn with_note(mut self, note: GenerationExclusionNote) -> Self {
+ self.notes.push(note);
+ self
+ }
+
+ fn applying_notes(&self) -> impl Iterator
- {
+ self.notes.iter()
+ }
+
+ fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str>
+ where
+ 'tcx: 'a,
+ {
+ self.name.as_str().into()
+ }
+}
+
+impl<'tcx> Annotated for FunctionCandidate<'tcx> {
+ fn with_note(mut self, note: GenerationExclusionNote) -> Self {
+ self.notes.push(note);
+ self
+ }
+
+ fn applying_notes(&self) -> impl Iterator
- {
+ self.notes
+ .iter()
+ .chain(self.arguments.iter().flat_map(|a| a.applying_notes()))
+ .chain(self.ret.applying_notes())
+ }
+
+ fn friendly_name<'a, 'b>(&'a self, _tcx: TyCtxt<'b>) -> Cow<'a, str>
+ where
+ 'b: 'a,
+ {
+ self.fn_name.as_str().into()
+ }
+}
+
+impl Annotated for FunctionArgCandidate {
+ fn with_note(mut self, note: GenerationExclusionNote) -> Self {
+ self.notes.push(note);
+ self
+ }
+
+ fn applying_notes(&self) -> impl Iterator
- {
+ self.notes.iter()
+ }
+
+ fn friendly_name<'a, 'tcx>(&'a self, _tcx: TyCtxt<'tcx>) -> Cow<'a, str>
+ where
+ 'tcx: 'a,
+ {
+ (&self.friendly_name).into()
+ }
+}
+
+pub struct AnnotationContextCollector<'n, 'tcx> {
+ notes_with_context: Vec<(String, &'n GenerationExclusionNote)>,
+ ctxt: TyCtxt<'tcx>,
+}
+
+impl<'n, 'tcx> AnnotationContextCollector<'n, 'tcx> {
+ pub fn new(ctxt: TyCtxt<'tcx>) -> Self {
+ Self {
+ notes_with_context: Default::default(),
+ ctxt,
+ }
+ }
+
+ pub fn build(self) -> Vec<(String, &'n GenerationExclusionNote)> {
+ self.notes_with_context
+ }
+
+ pub fn annotate(&mut self, candidate: &'n GenerationCandidate<'tcx, D>) {
+ let ctxt = candidate.friendly_name(self.ctxt);
+
+ for note in &candidate.notes {
+ self.notes_with_context.push((ctxt.to_string(), note))
+ }
+
+ for variant in &candidate.excluded_variants {
+ self.annotate_variant(&ctxt, variant);
+ }
+
+ for variant in &candidate.variants {
+ self.annotate_variant(&ctxt, variant);
+ }
+
+ for function in &candidate.excluded_functions {
+ self.annotate_function(&ctxt, function);
+ }
+ }
+
+ pub fn annotate_variant(&mut self, ctxt: &str, variant: &'n VariantCandidate<'tcx>) {
+ let ctxt = format!("{ctxt}::{}", variant.friendly_name(self.ctxt));
+
+ for note in &variant.notes {
+ self.notes_with_context.push((ctxt.to_string(), note))
+ }
+
+ for field in &variant.fields {
+ self.annotate_field(&ctxt, field)
+ }
+
+ for field in &variant.excluded_fields {
+ self.annotate_field(&ctxt, field)
+ }
+ }
+
+ pub fn annotate_field(&mut self, ctxt: &str, field: &'n FieldCandidate) {
+ let ctxt = format!("{ctxt} {} (field)", field.friendly_name(self.ctxt));
+ for note in &field.notes {
+ self.notes_with_context.push((ctxt.to_string(), note))
+ }
+ }
+
+ fn annotate_function(&mut self, ctxt: &str, function: &'n FunctionCandidate<'tcx>) {
+ let ctxt = format!("{ctxt} fn {}", function.friendly_name(self.ctxt));
+
+ for note in &function.notes {
+ self.notes_with_context.push((ctxt.to_string(), note))
+ }
+
+ for arg in &function.arguments {
+ self.annotate_arg(&ctxt, arg);
+ }
+
+ self.annotate_arg(&ctxt, &function.ret)
+ }
+
+ fn annotate_arg(&mut self, ctxt: &str, arg: &'n FunctionArgCandidate) {
+ let ctxt = format!("{ctxt} {} (arg)", arg.friendly_name(self.ctxt));
+
+ for note in &arg.notes {
+ self.notes_with_context.push((ctxt.to_string(), note))
+ }
+ }
+}
diff --git a/codegen/src/context.rs b/codegen/src/context.rs
index 6120402b31..c21fce4ff5 100644
--- a/codegen/src/context.rs
+++ b/codegen/src/context.rs
@@ -4,17 +4,18 @@ use cargo_metadata::camino::Utf8PathBuf;
use crate_feature_graph::WorkspaceGraph;
use indexmap::IndexMap;
use log::debug;
-use rustc_hir::def_id::DefId;
+use rustc_hir::def_id::{CrateNum, DefId, DefIndex};
use rustc_middle::ty::{AdtDef, TyCtxt};
use serde::Serialize;
-use crate::{ImportPathFinder, MetaLoader, TemplateContext};
+use crate::{ImportPathFinder, MetaLoader, TemplateContext, candidate::GenerationCandidate};
pub(crate) struct BevyCtxt<'tcx> {
pub(crate) tcx: TyCtxt<'tcx>,
pub(crate) meta_loader: MetaLoader,
- pub(crate) reflect_types: IndexMap>,
- pub(crate) cached_traits: CachedTraits,
+ pub(crate) reflect_types: IndexMap>>,
+ pub(crate) excluded_reflect_types: Vec>>>,
+ pub(crate) cached_traits: CachedItems,
pub(crate) path_finder: ImportPathFinder<'tcx>,
pub(crate) workspace: WorkspaceGraph,
@@ -35,6 +36,7 @@ impl<'tcx> BevyCtxt<'tcx> {
Self {
tcx,
reflect_types: Default::default(),
+ excluded_reflect_types: Default::default(),
cached_traits: Default::default(),
meta_loader: MetaLoader::new(meta_dirs.to_vec(), workspace_meta),
template_context: Default::default(),
@@ -58,45 +60,31 @@ impl<'tcx> BevyCtxt<'tcx> {
}
}
-#[derive(Clone, Default, Debug)]
-pub(crate) struct ReflectType<'tcx> {
- /// Map from traits to their implementations for the reflect type (from a selection)
- pub(crate) trait_impls: Option>>,
- /// Information about the ADT structure, fields, and variants
- pub(crate) variant_data: Option>,
- /// Functions passing criteria to be proxied
- pub(crate) valid_functions: Option>,
-
- /// Mapping from fields to the reflection strategy
- field_reflection_types: IndexMap,
-}
-
-impl ReflectType<'_> {
- pub(crate) fn set_field_reflection_strategies<
- I: Iterator
- ,
- >(
- &mut self,
- field_strats: I,
- ) {
- self.field_reflection_types = field_strats.collect();
- }
-
- pub(crate) fn get_field_reflection_strat(&self, field: DefId) -> Option<&ReflectionStrategy> {
- self.field_reflection_types.get(&field)
- }
-}
-
pub(crate) const DEF_PATHS_BMS_FROM_SCRIPT: [&str; 2] =
["bevy_mod_scripting_bindings::FromScript", "FromScript"];
pub(crate) const DEF_PATHS_BMS_INTO_SCRIPT: [&str; 2] =
["bevy_mod_scripting_bindings::IntoScript", "IntoScript"];
-pub(crate) const DEF_PATHS_REFLECT: [&str; 2] =
- ["bevy_reflect::PartialReflect", "reflect::PartialReflect"];
+pub(crate) const DEF_PATHS_REFLECT: [&str; 2] = [
+ "bevy_reflect::reflect::PartialReflect",
+ "reflect::PartialReflect",
+];
pub(crate) const DEF_PATHS_GET_TYPE_REGISTRATION: [&str; 2] = [
- "bevy_reflect::GetTypeRegistration",
+ "bevy_reflect::type_registry::GetTypeRegistration",
"type_registry::GetTypeRegistration",
];
+pub(crate) const DEF_PATHS_BMS_REF_WRAPPER: [&str; 2] = [
+ "bevy_mod_scripting_bindings::Ref",
+ "bevy_mod_scripting_bindings::function::Ref",
+];
+pub(crate) const DEF_PATHS_BMS_MUT_WRAPPER: [&str; 2] = [
+ "bevy_mod_scripting_bindings::Mut",
+ "bevy_mod_scripting_bindings::function::Mut",
+];
+pub(crate) const DEF_PATHS_BMS_VAL_WRAPPER: [&str; 2] = [
+ "bevy_mod_scripting_bindings::Val",
+ "bevy_mod_scripting_bindings::function::Val",
+];
/// A collection of traits which we search for in the codebase, some are included purely for the methods they provide,
/// others are later used for quick lookup of the type "does this type implement Display" etc.
@@ -121,42 +109,65 @@ pub(crate) const STD_OR_CORE_TRAITS: [&str; 13] = [
"cmp::PartialOrd",
];
-/// A collection of common traits stored for quick access.
-#[derive(Default)]
-pub(crate) struct CachedTraits {
- pub(crate) bms_into_script: Option,
- pub(crate) bms_from_script: Option,
- pub(crate) bevy_reflect_reflect: Option,
- pub(crate) bevy_reflect_get_type_registration: Option,
- /// Map from def_path_str to DefId of common std traits we work with
- /// these are the only trait impls from which we generate methods
- pub(crate) std_only_traits: HashMap,
- pub(crate) std_or_core_traits: HashMap,
+pub(crate) struct BmsTypes {
+ #[allow(dead_code)]
+ pub bindings_crate: CrateNum,
+ pub into_script: DefId,
+ pub from_script: DefId,
+ pub ref_wrapper: DefId,
+ pub val_wrapper: DefId,
+ pub mut_wrapper: DefId,
}
-impl CachedTraits {
- pub(crate) fn missing_bms_traits(&self) -> Vec<&'static str> {
- let mut missing = Vec::new();
- if self.bms_into_script.is_none() {
- missing.extend(DEF_PATHS_BMS_INTO_SCRIPT);
- }
- if self.bms_from_script.is_none() {
- missing.extend(DEF_PATHS_BMS_FROM_SCRIPT);
+pub(crate) struct BevyTypes {
+ #[allow(dead_code)]
+ pub reflect_crate: CrateNum,
+ pub reflect: DefId,
+ #[allow(dead_code)]
+ pub get_type_registration: DefId,
+}
+
+impl Default for BevyTypes {
+ fn default() -> Self {
+ Self {
+ reflect_crate: INVALID_CRATE_NUM,
+ reflect: INVALID_DEF_ID,
+ get_type_registration: INVALID_DEF_ID,
}
- missing
}
+}
- pub(crate) fn missing_bevy_traits(&self) -> Vec<&'static str> {
- let mut missing = Vec::new();
- if self.bevy_reflect_reflect.is_none() {
- missing.extend(DEF_PATHS_REFLECT);
- }
- if self.bevy_reflect_get_type_registration.is_none() {
- missing.extend(DEF_PATHS_GET_TYPE_REGISTRATION);
+const INVALID_CRATE_NUM: CrateNum = CrateNum::from_u16(u16::MAX);
+const INVALID_DEF_ID: DefId = DefId {
+ index: DefIndex::from_u16(u16::MAX),
+ krate: INVALID_CRATE_NUM,
+};
+
+impl Default for BmsTypes {
+ fn default() -> Self {
+ Self {
+ bindings_crate: INVALID_CRATE_NUM,
+ into_script: INVALID_DEF_ID,
+ from_script: INVALID_DEF_ID,
+ ref_wrapper: INVALID_DEF_ID,
+ val_wrapper: INVALID_DEF_ID,
+ mut_wrapper: INVALID_DEF_ID,
}
- missing
}
+}
+/// A collection of common traits stored for quick access.
+#[derive(Default)]
+pub(crate) struct CachedItems {
+ pub(crate) bms_types: BmsTypes,
+ pub(crate) bevy_types: BevyTypes,
+ /// Map from def_path_str to DefId of common std traits we work with
+ /// these are the only trait impls from which we generate methods
+ pub(crate) std_only_traits: HashMap,
+ pub(crate) std_or_core_traits: HashMap,
+}
+
+impl CachedItems {
pub(crate) fn missing_std_traits(&self) -> Vec {
let mut missing = Vec::new();
for trait_name in STD_ONLY_TRAITS {
@@ -190,17 +201,7 @@ impl CachedTraits {
// }
}
-#[derive(Clone, Debug)]
-pub(crate) struct FunctionContext {
- pub(crate) def_id: DefId,
- pub(crate) has_self: bool,
- pub(crate) is_unsafe: bool,
- pub(crate) trait_and_impl_did: Option<(DefId, DefId)>,
- /// strategies for input and output (last element is the output)
- pub(crate) reflection_strategies: Vec,
-}
-
-#[derive(PartialEq, Eq, Clone, Copy, Serialize, Debug)]
+#[derive(PartialEq, Eq, Clone, Copy, Serialize, Debug, Default)]
pub(crate) enum ReflectionStrategy {
/// The will have a known wrapper we can use
Proxy,
@@ -209,5 +210,6 @@ pub(crate) enum ReflectionStrategy {
/// Use a reflection primitive i.e. 'ReflectedValue', dynamic runtime reflection
Reflection,
/// Either ignored via 'reflect(ignore)' or not visible
+ #[default]
Filtered,
}
diff --git a/codegen/src/driver/mod.rs b/codegen/src/driver/mod.rs
index f963ff39e1..010d23556d 100644
--- a/codegen/src/driver/mod.rs
+++ b/codegen/src/driver/mod.rs
@@ -14,26 +14,23 @@ use cargo_metadata::{Metadata, camino::Utf8PathBuf};
pub use plugin::*;
use rustc_session::{EarlyDiagCtxt, config::ErrorOutputType};
-pub const CRATES_TO_RUN_PLUGIN_ON_ENV: &str = "CRATES_TO_RUN_PLUGIN_ON";
pub const CARGO_VERBOSE: &str = "CARGO_VERBOSE";
pub const WORKSPACE_GRAPH_FILE_ENV: &str = "WORKSPACE_GRAPH_FILE";
pub fn fetch_target_directory(metadata: &Metadata) -> Utf8PathBuf {
- let plugin_subdir = format!("plugin-{}", env!("RUSTC_CHANNEL"));
+ let plugin_subdir = format!("plugin-{}", crate::CHANNEL);
metadata.target_directory.join(plugin_subdir)
}
/// The top-level function that should be called in your user-facing binary.
-pub fn cli_main(plugin: T, include_crates: Vec, metadata: &Metadata) {
+pub fn cli_main(plugin: T, metadata: &Metadata) {
if env::args().any(|arg| arg == "-V") {
- println!("{}", plugin.version());
+ println!("{}", T::version());
return;
}
let target_dir = fetch_target_directory(metadata);
- let args = plugin.args(&target_dir);
-
let mut cmd = Command::new("cargo");
cmd.env("CARGO_TERM_COLOR", "always");
cmd.stdout(Stdio::inherit()).stderr(Stdio::inherit());
@@ -56,51 +53,53 @@ pub fn cli_main(plugin: T, include_crates: Vec, metadata
cmd.arg("-q");
}
- cmd.env(CRATES_TO_RUN_PLUGIN_ON_ENV, include_crates.join(","));
-
- let args_str = serde_json::to_string(&args.args).unwrap();
- log::debug!("{PLUGIN_ARGS}={args_str}");
- cmd.env(PLUGIN_ARGS, args_str);
+ plugin.serialize_to_env();
- plugin.modify_cargo(&mut cmd, &args.args);
+ plugin.modify_cargo(&mut cmd);
let exit_status = cmd.status().expect("failed to wait for cargo?");
exit(exit_status.code().unwrap_or(-1));
}
-// use std::{
-// env,
-// ops::Deref,
-// path::{Path, PathBuf},
-// process::{Command, exit},
-// };
-
-// use rustc_session::{EarlyDiagCtxt, config::ErrorOutputType};
-// use rustc_tools_util::VersionInfo;
-
-// use super::plugin::{PLUGIN_ARGS, RustcPlugin};
+fn with_next(iter: I) -> impl Iterator
- )>
+where
+ I: Iterator,
+ I::Item: Clone,
+{
+ let mut it = iter.peekable();
+ std::iter::from_fn(move || {
+ let current = it.next()?;
+ let next = it.peek().cloned();
+ Some((current, next))
+ })
+}
/// If a command-line option matches `find_arg`, then apply the predicate `pred` on its value. If
/// true, then return it. The parameter is assumed to be either `--arg=value` or `--arg value`.
-fn arg_value<'a, T: Deref>(
+fn arg_values<'a, T: Deref>(
args: &'a [T],
- find_arg: &str,
- pred: impl Fn(&str) -> bool,
-) -> Option<&'a str> {
- let mut args = args.iter().map(Deref::deref);
- while let Some(arg) = args.next() {
- let mut arg = arg.splitn(2, '=');
- if arg.next() != Some(find_arg) {
- continue;
+ find_arg: &'a str,
+ pred: impl Fn(&'a str) -> bool + 'static,
+) -> impl Iterator
- {
+ with_next(args.iter().map(Deref::deref)).filter_map(move |(arg, next_arg)| {
+ let mut split_arg = arg.splitn(2, '=');
+ if split_arg.next() != Some(find_arg) {
+ return None;
}
-
- match arg.next().or_else(|| args.next()) {
- Some(v) if pred(v) => return Some(v),
- _ => {}
+ match split_arg.next().or(next_arg) {
+ Some(v) if pred(v) => Some(v),
+ _ => None,
}
- }
- None
+ })
+}
+
+pub fn arg_value<'a, T: Deref>(
+ args: &'a [T],
+ find_arg: &'a str,
+ pred: impl Fn(&'a str) -> bool + 'static,
+) -> Option<&'a str> {
+ arg_values(args, find_arg, pred).next()
}
fn toolchain_path(home: Option, toolchain: Option) -> Option {
@@ -165,11 +164,8 @@ fn get_sysroot(orig_args: &[String]) -> (bool, String) {
(have_sys_root_arg, sys_root)
}
-struct DefaultCallbacks;
-impl rustc_driver::Callbacks for DefaultCallbacks {}
-
/// The top-level function that should be called by your internal driver binary.
-pub fn driver_main(plugin: T) {
+pub fn rustc_driver_main(plugin: T) {
let early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
rustc_driver::init_rustc_env_logger(&early_dcx);
@@ -179,7 +175,7 @@ pub fn driver_main(plugin: T) {
let (have_sys_root_arg, sys_root) = get_sysroot(&orig_args);
if orig_args.iter().any(|a| a == "--version" || a == "-V") {
- println!("{}", plugin.version());
+ println!("{}", T::version());
exit(0);
}
@@ -197,41 +193,36 @@ pub fn driver_main(plugin: T) {
// the driver directly without having to pass --sysroot or anything
let mut args: Vec = orig_args.clone();
if !have_sys_root_arg {
- args.extend(["--sysroot".into(), sys_root]);
+ args.extend(["--sysroot".into(), sys_root.clone()]);
};
+ plugin.modify_rustc(&mut args);
+
// On a given invocation of rustc, we have to decide whether to act as rustc,
// or actually execute the plugin. There are two conditions for executing the plugin:
// 1. Either we're supposed to run on all crates, or CARGO_PRIMARY_PACKAGE is set.
// 2. --print is NOT passed, since Cargo does that to get info about rustc.
- let primary_package = env::var("CARGO_PRIMARY_PACKAGE").is_ok();
+ // let primary_package = env::var("CARGO_PRIMARY_PACKAGE").is_ok();
let crate_being_built = arg_value(&args, "--crate-name", |_| true)
.as_ref()
.map(|s| s.to_string())
.unwrap_or_default();
- let is_target_crate = env::var(CRATES_TO_RUN_PLUGIN_ON_ENV)
- .is_ok_and(|crates| crates.split(',').any(|c| c == crate_being_built));
- let normal_rustc = arg_value(&args, "--print", |_| true).is_some();
-
- let run_plugin = !normal_rustc && is_target_crate;
-
- if run_plugin {
- // TODO: this is dangerous
- args.extend([String::from("--cap-lints"), String::from("warn")]);
- log::debug!("Running plugin on crate: {crate_being_built}");
- let plugin_args: T::Args =
- serde_json::from_str(&env::var(PLUGIN_ARGS).unwrap()).unwrap();
- plugin.run(args, plugin_args);
- } else {
- // ignore all lints that could break the comp in crates that we don't care about
- args.extend([String::from("--cap-lints"), String::from("warn")]);
- log::debug!(
- "Running normal Rust. Relevant variables:\
-normal_rustc={normal_rustc}, \
-is_target_crate={is_target_crate}, \
-primary_package={primary_package}"
- );
- rustc_driver_impl::run_compiler(&args, &mut DefaultCallbacks);
- }
+
+ // let run_mode = plugin.should_run(&crate_being_built);
+ // log::info!("crate {crate_being_built}, run mode: {run_mode:?}");
+ // let (should_run_plugin, should_skip) = match run_mode {
+ // RunMode::NormalRustc => (false, false),
+ // RunMode::Plugin => (true, false),
+ // RunMode::Skip => (false, true),
+ // };
+
+ let normal_rustc_cli_override = arg_value(&args, "--print", |_| true).is_some();
+
+ // TODO: this is dangerous
+ // ignore all lints that could break the comp in crates that we don't care about
+ // args.extend([String::from("--cap-lints"), String::from("warn")]);
+
+ log::debug!("Running plugin on crate: {crate_being_built}");
+ plugin.run(&crate_being_built, args, normal_rustc_cli_override);
}))
}
diff --git a/codegen/src/driver/plugin.rs b/codegen/src/driver/plugin.rs
index a15cf3164b..a830ae8a3d 100644
--- a/codegen/src/driver/plugin.rs
+++ b/codegen/src/driver/plugin.rs
@@ -1,30 +1,16 @@
use std::{borrow::Cow, process::Command};
-use cargo_metadata::camino::Utf8Path;
use serde::{Serialize, de::DeserializeOwned};
-/// Specification of a set of crates.
-pub enum CrateFilter {
- /// Every crate in the workspace and all transitive dependencies.
- AllCrates,
- /// Just crates in the workspace.
- OnlyWorkspace,
-}
-
-/// Arguments from your plugin to the rustc_plugin framework.
-pub struct RustcPluginArgs {
- /// Whatever CLI arguments you want to pass along.
- pub args: Args,
-
- /// Which crates you want to run the plugin on.
- pub filter: CrateFilter,
+#[derive(Debug)]
+pub enum RunMode {
+ NormalRustc,
+ Plugin,
+ Skip,
}
/// Interface between your plugin and the rustc_plugin framework.
-pub trait RustcPlugin: Sized {
- /// Command-line arguments passed by the user.
- type Args: Serialize + DeserializeOwned;
-
+pub trait RustcPlugin: Sized + Serialize + DeserializeOwned {
/// Returns the version of your plugin.
///
/// A sensible default is your plugin's Cargo version:
@@ -32,24 +18,31 @@ pub trait RustcPlugin: Sized {
/// ```ignore
/// env!("CARGO_PKG_VERSION").into()
/// ```
- fn version(&self) -> Cow<'static, str>;
+ fn version() -> Cow<'static, str>;
/// Returns the name of your driver binary as it's installed in the filesystem.
///
/// Should be just the filename, not the full path.
fn driver_name(&self) -> Cow<'static, str>;
- /// Parses and returns the CLI arguments for the plugin.
- fn args(&self, target_dir: &Utf8Path) -> RustcPluginArgs;
-
/// Optionally modify the `cargo` command that launches rustc.
/// For example, you could pass a `--feature` flag here.
- fn modify_cargo(&self, _cargo: &mut Command, _args: &Self::Args) {}
+ fn modify_cargo(&self, _cargo: &mut Command) {}
+
+ fn modify_rustc(&self, _compiler_args: &mut Vec) {}
/// Executes the plugin with a set of compiler and plugin args.
- fn run(self, compiler_args: Vec, plugin_args: Self::Args);
+ fn run(self, crate_name: &str, compiler_args: Vec, is_not_build_invocation: bool);
+
+ /// To be used after the PAYLOAD is initialized
+ fn initialize_from_env() -> Self {
+ serde_json::from_str(&std::env::var(PLUGIN_PAYLOAD).unwrap()).unwrap()
+ }
+
+ /// persists the plugin in the process environment for children to be able to call [`Self::initialize_from_env`]
+ fn serialize_to_env(&self) {
+ unsafe { std::env::set_var(PLUGIN_PAYLOAD, serde_json::to_string(&self).unwrap()) }
+ }
}
-/// The name of the environment variable shared between the CLI and the driver.
-/// Must not conflict with any other env var used by Cargo.
-pub const PLUGIN_ARGS: &str = "PLUGIN_ARGS";
+pub const PLUGIN_PAYLOAD: &str = "PLUGIN_PAYLOAD";
diff --git a/codegen/src/impls.rs b/codegen/src/impls.rs
new file mode 100644
index 0000000000..2d4adde82f
--- /dev/null
+++ b/codegen/src/impls.rs
@@ -0,0 +1,92 @@
+use rustc_infer::{
+ infer::TyCtxtInferExt,
+ traits::{Obligation, ObligationCause, PredicateObligation},
+};
+use rustc_middle::ty::{Ty, TyCtxt, TypingEnv};
+use rustc_trait_selection::traits::ObligationCtxt;
+
+use crate::{BmsTypes, candidate::GenerationExclusionNote};
+
+pub(crate) trait BmsTraitChecker<'tcx> {
+ /// Checks if the given type implements 'FromScript', assuming a monomorphised type.
+ fn implements_from_script(
+ &self,
+ self_type: Ty<'tcx>,
+ bms_types: &BmsTypes,
+ tcx: TyCtxt<'tcx>,
+ ) -> Result<(), GenerationExclusionNote>;
+
+ /// Checks if the given type implements 'IntoScript', assuming a monomorphised type.
+ fn implements_into_script(
+ &self,
+ self_type: Ty<'tcx>,
+ bms_types: &BmsTypes,
+ tcx: TyCtxt<'tcx>,
+ ) -> Result<(), GenerationExclusionNote>;
+}
+
+fn typing_env_for_impl<'tcx>(_self_type: Ty<'tcx>, _tcx: TyCtxt<'tcx>) -> TypingEnv<'tcx> {
+ // if let Some(adt) = self_type.ty_adt_def() {
+ // TypingEnv::non_body_analysis(tcx, adt.did())
+ // } else {
+ TypingEnv::fully_monomorphized()
+ // }
+}
+
+impl<'tcx> BmsTraitChecker<'tcx> for Ty<'tcx> {
+ fn implements_from_script(
+ &self,
+ self_type: Ty<'tcx>,
+ bms_types: &BmsTypes,
+ tcx: TyCtxt<'tcx>,
+ ) -> Result<(), GenerationExclusionNote> {
+ let typing_env = typing_env_for_impl(self_type, tcx);
+ check_trait_impl(tcx, typing_env, self_type, bms_types.from_script)
+ }
+
+ fn implements_into_script(
+ &self,
+ self_type: Ty<'tcx>,
+ bms_types: &BmsTypes,
+ tcx: TyCtxt<'tcx>,
+ ) -> Result<(), GenerationExclusionNote> {
+ let typing_env = typing_env_for_impl(self_type, tcx);
+ check_trait_impl(tcx, typing_env, self_type, bms_types.into_script)
+ }
+}
+
+fn check_trait_impl<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ typing_env: TypingEnv<'tcx>,
+ self_ty: Ty<'tcx>,
+ trait_def_id: rustc_hir::def_id::DefId,
+) -> Result<(), GenerationExclusionNote> {
+ let param_env = typing_env.param_env;
+
+ let infcx = tcx.infer_ctxt().build(typing_env.typing_mode);
+
+ let trait_ref = rustc_middle::ty::TraitRef::new(tcx, trait_def_id, [self_ty]);
+
+ let obligation: PredicateObligation<'tcx> =
+ Obligation::new(tcx, ObligationCause::dummy(), param_env, trait_ref);
+
+ let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+ ocx.register_obligation(obligation);
+
+ let errors = ocx.evaluate_obligations_error_on_ambiguity();
+
+ if errors.is_empty() {
+ return Ok(());
+ }
+
+ let msg = format!(
+ "type `{self_ty}` does NOT implement required trait, errors: {}. param env: {param_env:?}",
+ errors
+ .into_iter()
+ .map(|e| format!("{e:?}"))
+ .collect::>()
+ .join(",")
+ );
+
+ Err(GenerationExclusionNote::Reason(msg))
+}
diff --git a/codegen/src/import_path.rs b/codegen/src/import_path.rs
index 4bae0d0f0a..dec51ed6fc 100644
--- a/codegen/src/import_path.rs
+++ b/codegen/src/import_path.rs
@@ -1,8 +1,9 @@
-use indexmap::IndexMap;
+use crate_feature_graph::WorkspaceGraph;
+use indexmap::{IndexMap, IndexSet};
use log::trace;
use rustc_hir::{
def::DefKind,
- def_id::{CrateNum, DefId},
+ def_id::{CrateNum, DefId, LOCAL_CRATE},
};
use rustc_middle::ty::TyCtxt;
@@ -12,6 +13,18 @@ pub(crate) enum ImportPathElement {
Rename(DefId, String),
/// direct import of the def id by name
Item(DefId),
+ /// A crate root
+ Crate(CrateNum),
+}
+
+impl ImportPathElement {
+ pub fn def_id(&self) -> Option {
+ Some(match self {
+ Self::Rename(did, _) => *did,
+ Self::Item(did) => *did,
+ _ => return None,
+ })
+ }
}
impl std::fmt::Debug for ImportPathElement {
@@ -19,6 +32,7 @@ impl std::fmt::Debug for ImportPathElement {
match self {
ImportPathElement::Rename(did, name) => write!(f, "{did:?} as {name}"),
ImportPathElement::Item(did) => write!(f, "{did:?}"),
+ ImportPathElement::Crate(crate_num) => write!(f, "{crate_num:?}"),
}
}
}
@@ -29,6 +43,7 @@ impl std::fmt::Debug for ImportPathElement {
pub(crate) struct ImportPathFinder<'tcx> {
pub(crate) tcx: TyCtxt<'tcx>,
pub(crate) cache: IndexMap>>,
+ pub(crate) crawled_crates: IndexSet,
pub(crate) include_private_paths: bool,
pub(crate) import_path_processor: Option String>>,
}
@@ -45,21 +60,66 @@ impl<'tcx> ImportPathFinder<'tcx> {
cache: Default::default(),
include_private_paths,
import_path_processor,
+ crawled_crates: Default::default(),
}
}
- pub(crate) fn crawl_crate(&mut self, crate_num: CrateNum) {
- self.crawl_module(crate_num.as_def_id(), &[])
+ /// Sort the import paths according to some heuristics, so best ones are first
+ pub(crate) fn stable_sort(&mut self, graph: &WorkspaceGraph) {
+ for (_, values) in &mut self.cache {
+ values.sort_by_cached_key(|k| Self::path_score(k, graph, self.tcx));
+ }
+ }
+
+ #[allow(dead_code)]
+ pub(crate) fn crawled_items_in_crate(&self, krate: CrateNum) -> impl Iterator
- {
+ self.cache
+ .keys()
+ .filter_map(move |i| (i.krate == krate).then_some(*i))
+ }
+
+ /// Higher is worse
+ fn path_score(path: &[ImportPathElement], graph: &WorkspaceGraph, tcx: TyCtxt) -> usize {
+ let length_score = path.len();
+ // crate proximity score
+ let mut crate_proximity_score = 0;
+ if let Some(ImportPathElement::Crate(crate_num)) = path.first() {
+ let crate_name = tcx.crate_name(*crate_num);
+ let is_std_or_core = crate_name.as_str() == "std" || crate_name.as_str() == "core";
+ let not_in_workspace = !graph
+ .all_enabled_workspace_crates()
+ .iter()
+ .any(|c| c.to_string().as_str() == crate_name.as_str());
+
+ let is_not_local_crate = if &LOCAL_CRATE != crate_num && !is_std_or_core {
+ 10
+ } else {
+ 0
+ };
+ let is_not_in_workspace = if not_in_workspace && !is_std_or_core {
+ 10
+ } else {
+ 0
+ };
+ crate_proximity_score = is_not_local_crate + is_not_in_workspace;
+ }
+ length_score + crate_proximity_score
+ }
+
+ pub(crate) fn ensure_crate_crawled(&mut self, crate_num: CrateNum) {
+ if !self.crawled_crates.contains(&crate_num) {
+ self.crawl_module(
+ crate_num.as_def_id(),
+ &[ImportPathElement::Crate(crate_num)],
+ );
+ self.crawled_crates.insert(crate_num);
+ }
}
fn crawl_module(&mut self, did: DefId, frontier: &[ImportPathElement]) {
trace!("Crawling module {did:?}");
- let mut new_frontier = frontier.to_vec();
- new_frontier.push(ImportPathElement::Item(did));
- // do not allow modification or weird things happen
- let new_frontier = &new_frontier;
-
+ // Get children of the module
let children = if did.is_local() {
self.tcx.module_children_local(did.expect_local())
} else {
@@ -67,49 +127,88 @@ impl<'tcx> ImportPathFinder<'tcx> {
};
for child in children {
- let rename = child.ident.to_string();
+ // Skip if the child has no DefId
+ let did = match child.res.opt_def_id() {
+ Some(did) => did,
+ None => {
+ trace!("Skipping child without did {:?}", child.ident);
+ continue;
+ }
+ };
+ // Skip private items if we don't include them
if !self.include_private_paths && !child.vis.is_public() {
- trace!("Skipping private child {rename:?}");
+ trace!("Skipping private child {:?}", child.ident);
continue;
}
- let did = if let Some(did) = child.res.opt_def_id() {
- did
- } else {
- continue;
- };
-
- trace!(
- "Crawling item: '{:?}', of kind: '{:?}'",
- did,
- self.tcx.def_kind(did)
- );
+ // skip non local items, i.e. don't go crawling serde
+ if !did.is_local() {
+ trace!("Skipping non-local child {:?}", child.ident);
+ // continue;
+ }
- match self.tcx.def_kind(did) {
- DefKind::Mod => self.crawl_module(did, new_frontier),
- DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => {
- // save the rename and the def id
+ let rename = (Some(child.ident.name) != self.tcx.opt_item_name(did))
+ .then_some(child.ident.as_str());
- let mut new_frontier = new_frontier.clone();
- new_frontier.push(ImportPathElement::Rename(did, rename));
+ self.crawl_item(did, frontier, rename);
+ }
+ }
- trace!("saving import path for {did:?}: {new_frontier:?}");
- self.cache.entry(did).or_default().push(new_frontier);
+ fn crawl_item(&mut self, did: DefId, frontier: &[ImportPathElement], rename: Option<&str>) {
+ trace!(
+ "Crawling item: '{:?}', of kind: '{:?}'",
+ did,
+ self.tcx.def_kind(did)
+ );
+
+ match self.tcx.def_kind(did) {
+ DefKind::Mod => {
+ // Only recurse if this DefId is not already in the current path
+ if frontier
+ .iter()
+ .any(|el| el.def_id().is_some_and(|id| id == did))
+ {
+ trace!("Cycle detected for {did:?}, skipping recursion");
+ return;
}
- _ => continue,
+ let mut new_frontier = frontier.to_vec();
+ new_frontier.push(
+ rename
+ .map(|rename| ImportPathElement::Rename(did, rename.to_string()))
+ .unwrap_or(ImportPathElement::Item(did)),
+ );
+
+ self.crawl_module(did, &new_frontier)
+ }
+
+ DefKind::Struct | DefKind::Union | DefKind::Enum | DefKind::Trait => {
+ // Save the rename and the DefId
+ let mut path_for_item = frontier.to_vec();
+
+ path_for_item.push(ImportPathElement::Item(did));
+
+ trace!("Saving import path for {did:?}: {path_for_item:?}");
+ self.cache.entry(did).or_default().push(path_for_item);
}
+
+ _ => (),
}
}
+ /// Like find_import_paths but won't always return at least one path
+ pub(crate) fn find_import_paths_no_fallback(&self, def_id: DefId) -> Option> {
+ self.cache.get(&def_id).map(|v| {
+ v.iter()
+ .map(|elems| self.import_path_to_def_string(elems))
+ .collect()
+ })
+ }
+
+ /// Finds the import path for the item if there is one given the current settings
+ /// or returns a fallback value based on the defID which might not be accurate
pub(crate) fn find_import_paths(&self, def_id: DefId) -> Vec {
- self.cache
- .get(&def_id)
- .map(|v| {
- v.iter()
- .map(|elems| self.import_path_to_def_string(elems))
- .collect()
- })
+ self.find_import_paths_no_fallback(def_id)
.unwrap_or_else(|| {
let path = self.tcx.def_path_str(def_id);
if let Some(p) = &self.import_path_processor {
@@ -125,7 +224,19 @@ impl<'tcx> ImportPathFinder<'tcx> {
.iter()
.map(|elem| match elem {
ImportPathElement::Rename(_, name) => name.to_owned(),
- ImportPathElement::Item(did) => self.tcx.item_name(*did).to_ident_string(),
+ ImportPathElement::Item(did) => self
+ .tcx
+ .opt_item_name(*did)
+ .expect("missing item name")
+ .to_ident_string(),
+ ImportPathElement::Crate(crate_num) => {
+ self.tcx.crate_name(*crate_num).to_ident_string()
+ }
+ })
+ .inspect(|e| {
+ if e.is_empty() {
+ panic!("empty path elem: {e}")
+ }
})
.collect::>()
.join("::");
diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs
index 32d2e6a058..6397fa8057 100644
--- a/codegen/src/lib.rs
+++ b/codegen/src/lib.rs
@@ -1,4 +1,4 @@
-#![feature(rustc_private, let_chains)]
+#![feature(rustc_private)]
#![deny(rustc::internal)]
extern crate rustc_ast;
@@ -14,28 +14,34 @@ extern crate rustc_middle;
extern crate rustc_session;
extern crate rustc_span;
extern crate rustc_trait_selection;
+extern crate rustc_type_ir;
mod args;
-mod callback;
+mod candidate;
mod context;
+mod impls;
mod import_path;
mod meta;
mod modifying_file_loader;
mod passes;
mod plugin;
mod template;
+mod ty_convert;
// pub(crate) use args::*;
pub use args::{Args, Command, WorkspaceMeta};
-pub(crate) use callback::*;
pub(crate) use context::*;
+pub use driver::*;
pub(crate) use import_path::*;
pub use meta::MetaLoader;
pub(crate) use meta::*;
pub(crate) use passes::*;
-pub use plugin::BevyAnalyzer;
+pub use plugin::*;
pub(crate) use template::*;
pub use template::{
Collect, Crate, TEMPLATE_DIR, TemplateKind, configure_tera, extend_context_with_args,
};
pub mod driver;
+
+/// The rustc toolchain this crate was built with and needs to work with
+pub const CHANNEL: &str = env!("RUSTC_CHANNEL");
diff --git a/codegen/src/meta.rs b/codegen/src/meta.rs
index fa4afdc930..35590fcb3e 100644
--- a/codegen/src/meta.rs
+++ b/codegen/src/meta.rs
@@ -7,6 +7,7 @@ use std::{
use cargo_metadata::camino::Utf8PathBuf;
use chrono::NaiveDateTime;
+use indexmap::IndexMap;
use log::trace;
use rustc_hir::def_id::DefPathHash;
use serde::{Deserialize, Serialize, Serializer};
@@ -38,7 +39,7 @@ pub struct Meta {
pub(crate) version: String,
/// a map of crate names to the features that crate was compiled with
- pub(crate) dependencies: HashMap,
+ pub(crate) dependencies: IndexMap,
}
#[derive(Serialize, Deserialize, Clone, Debug)]
diff --git a/codegen/src/modifying_file_loader.rs b/codegen/src/modifying_file_loader.rs
index 07f2075fbe..672b8e023d 100644
--- a/codegen/src/modifying_file_loader.rs
+++ b/codegen/src/modifying_file_loader.rs
@@ -27,23 +27,16 @@ 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_, excluded_files) in &[
- ("bevy_reflect", vec!["crates/bevy_reflect/src/lib.rs"]),
- ("bevy_mod_scripting_bindings", vec![]),
- ] {
- if !f.contains(&format!("extern crate {crate_}"))
- && !excluded_files
- .iter()
- .any(|s| path.to_str().unwrap().contains(s))
- {
- if f.contains(&format!("pub use {crate_}")) {
+ for krate in &["bevy_mod_scripting_bindings"] {
+ if !f.contains(&format!("extern crate {krate}")) {
+ if f.contains(&format!("pub use {krate}")) {
f.push_str(&format!(
- "#[allow(unused_extern_crates)] pub extern crate {crate_};"
+ "#[allow(unused_extern_crates)] pub extern crate {krate};"
));
} else {
// this causes issues in proc macros so let's make it private where we can
f.push_str(&format!(
- "#[allow(unused_extern_crates)] extern crate {crate_};"
+ "#[allow(unused_extern_crates)] extern crate {krate};"
));
}
}
diff --git a/codegen/src/passes/cache_items.rs b/codegen/src/passes/cache_items.rs
new file mode 100644
index 0000000000..6aeb0329f6
--- /dev/null
+++ b/codegen/src/passes/cache_items.rs
@@ -0,0 +1,180 @@
+use log::{debug, trace};
+use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_span::Symbol;
+
+use crate::{
+ Args, BevyCtxt, BevyTypes, BmsTypes, DEF_PATHS_BMS_FROM_SCRIPT, DEF_PATHS_BMS_INTO_SCRIPT,
+ DEF_PATHS_BMS_MUT_WRAPPER, DEF_PATHS_BMS_REF_WRAPPER, DEF_PATHS_BMS_VAL_WRAPPER,
+ DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_REFLECT, STD_ONLY_TRAITS, STD_OR_CORE_TRAITS,
+};
+// tODO: verify there is only one Reflect trait impl
+// fn dump_items(ctxt: &BevyCtxt) -> String {
+// let mut buffer = String::new();
+// buffer.push_str("traits:\n");
+// for t in ctxt.tcx.all_traits_including_private() {
+// buffer.push_str(&ctxt.tcx.def_path_str(t));
+// buffer.push_str(", ");
+// }
+// buffer.push_str("bms_bindings items:\n");
+// for item in ctxt
+// .path_finder
+// .crawled_items_in_crate(ctxt.cached_traits.bms_types.bindings_crate)
+// {
+// buffer.push_str(&ctxt.tcx.def_path_str(item));
+// buffer.push_str(", ");
+// }
+
+// buffer
+// }
+
+pub(crate) fn cache_bms_items(ctxt: &mut BevyCtxt<'_>) -> BmsTypes {
+ let bindings_crate = *ctxt
+ .tcx
+ .crates(())
+ .iter()
+ .find(|c| ctxt.tcx.crate_name(**c).as_str() == "bevy_mod_scripting_bindings")
+ .expect("bevy_mod_scripting_bindings crate not linked");
+ let mut val_wrapper = None;
+ let mut ref_wrapper = None;
+ let mut mut_wrapper = None;
+ let mut into_script = None;
+ let mut from_script = None;
+ ctxt.path_finder.ensure_crate_crawled(bindings_crate);
+ for item in ctxt.path_finder.crawled_items_in_crate(bindings_crate) {
+ let item_name = ctxt.tcx.def_path_str(item);
+ let item_name = item_name.as_str();
+ if DEF_PATHS_BMS_VAL_WRAPPER.contains(&item_name) {
+ val_wrapper = Some(item)
+ } else if DEF_PATHS_BMS_REF_WRAPPER.contains(&item_name) {
+ ref_wrapper = Some(item)
+ } else if DEF_PATHS_BMS_MUT_WRAPPER.contains(&item_name) {
+ mut_wrapper = Some(item)
+ } else if DEF_PATHS_BMS_FROM_SCRIPT.contains(&item_name) {
+ from_script = Some(item)
+ } else if DEF_PATHS_BMS_INTO_SCRIPT.contains(&item_name) {
+ into_script = Some(item)
+ }
+ }
+
+ BmsTypes {
+ bindings_crate,
+ into_script: into_script.expect("could not find IntoScript trait from bms linked"),
+ from_script: from_script.expect("could not find FromScript trait from bms linked"),
+ ref_wrapper: ref_wrapper.expect("could not find Ref type from bms linked"),
+ val_wrapper: val_wrapper.expect("could not find Val type from bms linked"),
+ mut_wrapper: mut_wrapper.expect("could not find Mut type from bms linked"),
+ }
+}
+
+pub(crate) fn cache_bevy_items(ctxt: &mut BevyCtxt<'_>) -> Result {
+ let reflect_crates = ctxt
+ .tcx
+ .crates(())
+ .iter()
+ .chain(std::iter::once(&LOCAL_CRATE))
+ .filter(|c| ctxt.tcx.crate_name(**c).as_str() == "bevy_reflect")
+ .collect::>();
+
+ // if reflect_crates.len() != 1 {
+ // return Err(format!(
+ // "Either found none or multiple bevy_reflect crates: {:?}",
+ // reflect_crates
+ // .iter()
+ // .map(|c| ctxt.tcx.def_path_str(c.as_def_id()))
+ // .collect::>()
+ // .join(",")
+ // ));
+ // }
+ let reflect_crate = **reflect_crates.last().unwrap();
+
+ ctxt.path_finder.ensure_crate_crawled(reflect_crate);
+ let mut reflect = None;
+ let mut get_type_registration = None;
+ for item in ctxt.path_finder.crawled_items_in_crate(reflect_crate) {
+ let item_name = ctxt.tcx.def_path_str(item);
+ let item_name = item_name.as_str();
+ if DEF_PATHS_REFLECT.contains(&item_name) {
+ reflect = Some(item)
+ } else if DEF_PATHS_GET_TYPE_REGISTRATION.contains(&item_name) {
+ get_type_registration = Some(item)
+ }
+ }
+
+ Ok(BevyTypes {
+ reflect_crate,
+ reflect: reflect.ok_or("could not find Reflect from bevy_reflect linked")?,
+ get_type_registration: get_type_registration
+ .ok_or("could not find GetTypeRegistration from bevy_reflect linked")?,
+ })
+}
+
+/// Finds and caches relevant traits, if they cannot be found throws an ICE
+pub(crate) fn cache_items(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
+ ctxt.cached_traits.bms_types = cache_bms_items(ctxt);
+ ctxt.cached_traits.bevy_types = match cache_bevy_items(ctxt) {
+ Ok(t) => t,
+ Err(err) => {
+ log::warn!(
+ "could not cache bevy types in crate {}. {err}. Will not generate bindings.",
+ ctxt.tcx.crate_name(LOCAL_CRATE)
+ );
+ return false;
+ }
+ };
+
+ let tcx = &ctxt.tcx;
+
+ for trait_did in tcx.all_traits_including_private() {
+ let def_path_str = tcx.def_path_str(trait_did);
+ if STD_ONLY_TRAITS.contains(&def_path_str.as_str()) {
+ trace!("found std trait def id: {trait_did:?}");
+ ctxt.cached_traits
+ .std_only_traits
+ .insert(def_path_str.to_string(), trait_did);
+ } else if let Some(full_name) = STD_OR_CORE_TRAITS.iter().find(|name| {
+ (Some(**name) == def_path_str.strip_prefix("core::"))
+ || (Some(**name) == def_path_str.strip_prefix("std::"))
+ }) {
+ trace!("found core trait def id: {trait_did:?}");
+ ctxt.cached_traits
+ .std_or_core_traits
+ .insert(full_name.to_string(), trait_did);
+ }
+ }
+
+ let missing_std_traits = ctxt.cached_traits.missing_std_traits();
+ if !missing_std_traits.is_empty() {
+ debug!(
+ "Could not find std traits: [{}] in crate: {}, this might lead to missing methods in the generated API.",
+ missing_std_traits.join(", "),
+ tcx.crate_name(LOCAL_CRATE),
+ );
+ }
+
+ // some crates specifically do not have std in scope via `#![no_std]` which means we do not care about these traits
+ let has_std = tcx
+ .get_attrs_by_path(LOCAL_CRATE.as_def_id(), &[Symbol::intern("no_std")])
+ .map(|_| ())
+ .next()
+ .is_none();
+
+ log::trace!("has_std: {has_std}");
+
+ // if has_std && !ctxt.cached_traits.has_all_std_source_traits() {
+ // log::debug!(
+ // "all traits: {}",
+ // tcx.all_traits()
+ // .map(|t| tcx.def_path_str(t).to_string())
+ // .collect::>()
+ // .join(", ")
+ // );
+
+ // panic!(
+ // "Could not find traits: [{}] in crate: {}, did bootstrapping go wrong?",
+ // ctxt.cached_traits.missing_std_source_traits().join(", "),
+ // tcx.crate_name(LOCAL_CRATE)
+ // )
+ // }
+
+ true
+}
diff --git a/codegen/src/passes/cache_traits.rs b/codegen/src/passes/cache_traits.rs
deleted file mode 100644
index d44f30eadb..0000000000
--- a/codegen/src/passes/cache_traits.rs
+++ /dev/null
@@ -1,109 +0,0 @@
-use log::{trace, warn};
-use rustc_hir::def_id::LOCAL_CRATE;
-use rustc_middle::ty::TyCtxt;
-use rustc_span::Symbol;
-
-use crate::{
- Args, BevyCtxt, DEF_PATHS_BMS_FROM_SCRIPT, DEF_PATHS_BMS_INTO_SCRIPT,
- DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_REFLECT, STD_ONLY_TRAITS, STD_OR_CORE_TRAITS,
-};
-
-fn dump_traits(tcx: &TyCtxt) -> String {
- let mut buffer = String::new();
- for t in tcx.all_traits() {
- buffer.push_str(&tcx.def_path_str(t));
- buffer.push_str(", ");
- }
- buffer
-}
-
-/// Finds and caches relevant traits, if they cannot be found throws an ICE
-pub(crate) fn cache_traits(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
- let tcx = &ctxt.tcx;
-
- for trait_did in tcx.all_traits() {
- let def_path_str = tcx.def_path_str(trait_did);
- 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()) {
- trace!("found GetTypeRegistration trait def id: {trait_did:?}");
- ctxt.cached_traits.bevy_reflect_get_type_registration = Some(trait_did);
- } else if STD_ONLY_TRAITS.contains(&def_path_str.as_str()) {
- trace!("found std trait def id: {trait_did:?}");
- ctxt.cached_traits
- .std_only_traits
- .insert(def_path_str.to_string(), trait_did);
- } else if let Some(full_name) = STD_OR_CORE_TRAITS.iter().find(|name| {
- (Some(**name) == def_path_str.strip_prefix("core::"))
- || (Some(**name) == def_path_str.strip_prefix("std::"))
- }) {
- trace!("found core trait def id: {trait_did:?}");
- ctxt.cached_traits
- .std_or_core_traits
- .insert(full_name.to_string(), trait_did);
- } else if DEF_PATHS_BMS_INTO_SCRIPT.contains(&def_path_str.as_str()) {
- trace!("found IntoScript trait def id: {trait_did:?}");
- ctxt.cached_traits.bms_into_script = Some(trait_did);
- } else if DEF_PATHS_BMS_FROM_SCRIPT.contains(&def_path_str.as_str()) {
- trace!("found FromScript trait def id: {trait_did:?}");
- ctxt.cached_traits.bms_from_script = Some(trait_did);
- }
- }
-
- let missing_bevy_traits = ctxt.cached_traits.missing_bevy_traits();
- if !missing_bevy_traits.is_empty() {
- panic!(
- "Could not find traits: [{}] in crate: {}, did bootstrapping go wrong? Available traits: {}",
- missing_bevy_traits.join(", "),
- tcx.crate_name(LOCAL_CRATE),
- dump_traits(tcx)
- );
- }
-
- let missing_bms_traits = ctxt.cached_traits.missing_bms_traits();
- if !missing_bms_traits.is_empty() {
- panic!(
- "Could not find traits: [{}] in crate: {}, did bootstrapping go wrong? Available traits: {}",
- missing_bms_traits.join(", "),
- tcx.crate_name(LOCAL_CRATE),
- dump_traits(tcx)
- );
- }
-
- let missing_std_traits = ctxt.cached_traits.missing_std_traits();
- if !missing_std_traits.is_empty() {
- warn!(
- "Could not find std traits: [{}] in crate: {}, this might lead to missing methods in the generated API.",
- missing_std_traits.join(", "),
- tcx.crate_name(LOCAL_CRATE),
- );
- }
-
- // some crates specifically do not have std in scope via `#![no_std]` which means we do not care about these traits
- let has_std = tcx
- .get_attrs_by_path(LOCAL_CRATE.as_def_id(), &[Symbol::intern("no_std")])
- .map(|_| ())
- .next()
- .is_none();
-
- log::trace!("has_std: {has_std}");
-
- // if has_std && !ctxt.cached_traits.has_all_std_source_traits() {
- // log::debug!(
- // "all traits: {}",
- // tcx.all_traits()
- // .map(|t| tcx.def_path_str(t).to_string())
- // .collect::>()
- // .join(", ")
- // );
-
- // panic!(
- // "Could not find traits: [{}] in crate: {}, did bootstrapping go wrong?",
- // ctxt.cached_traits.missing_std_source_traits().join(", "),
- // tcx.crate_name(LOCAL_CRATE)
- // )
- // }
-
- true
-}
diff --git a/codegen/src/passes/codegen.rs b/codegen/src/passes/codegen.rs
index 7584b2256a..a038932266 100644
--- a/codegen/src/passes/codegen.rs
+++ b/codegen/src/passes/codegen.rs
@@ -3,7 +3,7 @@ use std::{
io::Write,
};
-use log::info;
+use log::debug;
use rustc_hir::def_id::LOCAL_CRATE;
use tera::Context;
@@ -11,24 +11,23 @@ use crate::{Args, BevyCtxt, TemplateKind, configure_tera};
/// generates a module with the appropriate wrappers for all the found reflection ADT's in the crate
pub(crate) fn codegen(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool {
- let (output, templates) = match &args.cmd {
- crate::Command::Generate {
- output, templates, ..
- } => (output, templates),
+ let templates = match &args.cmd {
+ crate::Command::Generate { templates, .. } => templates,
_ => return true,
};
let tera = configure_tera(ctxt.tcx.crate_name(LOCAL_CRATE).as_str(), templates);
// perform code gen using templates
- fs::create_dir_all(output).unwrap();
- info!("Writing code files to : {output}");
+ fs::create_dir_all(&args.output).unwrap();
+ debug!("Writing code files to : {}", args.output);
let template_data = ctxt.template_context.as_ref().unwrap();
let mut context = Context::from_serialize(template_data).unwrap();
crate::extend_context_with_args(args.template_args.as_deref(), &mut context);
// generate crate artifact
- let mut file = File::create(output.join(format!("{}.rs", template_data.crate_name))).unwrap();
+ let mut file =
+ File::create(args.output.join(format!("{}.rs", template_data.crate_name))).unwrap();
match tera.render_to(
&TemplateKind::CrateArtifact.to_string(),
diff --git a/codegen/src/passes/crawl_paths.rs b/codegen/src/passes/crawl_paths.rs
index 64f44893e1..596976e2e6 100644
--- a/codegen/src/passes/crawl_paths.rs
+++ b/codegen/src/passes/crawl_paths.rs
@@ -4,10 +4,11 @@ use crate::{Args, BevyCtxt};
/// Finds and caches import paths
pub(crate) fn crawl_paths(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
- ctxt.path_finder.crawl_crate(LOCAL_CRATE);
+ ctxt.path_finder.ensure_crate_crawled(LOCAL_CRATE);
- // for c in ctxt.tcx.crates(()) {
- // ctxt.path_finder.crawl_crate(*c);
- // }
+ for c in ctxt.tcx.crates(()) {
+ ctxt.path_finder.ensure_crate_crawled(*c);
+ }
+ ctxt.path_finder.stable_sort(&ctxt.workspace);
true
}
diff --git a/codegen/src/passes/find_methods_and_fields.rs b/codegen/src/passes/find_methods_and_fields.rs
index 7efe4d8427..d0c5157851 100644
--- a/codegen/src/passes/find_methods_and_fields.rs
+++ b/codegen/src/passes/find_methods_and_fields.rs
@@ -1,294 +1,331 @@
+use std::io::Write;
+
use indexmap::IndexMap;
-use log::{info, trace};
+use itertools::Itertools;
+use log::trace;
use rustc_hir::{
- Safety,
+ StableSince,
def_id::{DefId, LOCAL_CRATE},
};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_middle::ty::{
- AdtKind, AssocKind, FieldDef, FnSig, GenericArgs, Ty, TyCtxt, TyKind, TypingEnv,
-};
+use rustc_infer::{infer::TyCtxtInferExt, traits::{Obligation, ObligationCause}};
+use rustc_middle::ty::{self, AdtDef, AssocKind, FnSig, GenericArgs, Ty, TyCtxt, TyKind, TypingEnv};
use rustc_span::Symbol;
-use rustc_trait_selection::infer::InferCtxtExt;
+use rustc_trait_selection::{infer::InferCtxtExt, traits::ObligationCtxt};
use crate::{
- Args, BevyCtxt, CachedTraits, FunctionContext, MetaLoader, ReflectType, ReflectionStrategy,
+ candidate::{
+ Annotated, AnnotationContextCollector, FieldCandidate, FunctionArgCandidate,
+ FunctionCandidate, FunctionCandidateKind, GenerationCandidate, GenerationExclusionNote,
+ VariantCandidate,
+ }, impls::BmsTraitChecker, ty_convert::{wrap_non_primtiives}, Args, BevyCtxt, CachedItems, MetaLoader, ReflectionStrategy
};
/// Finds all methods and fields which can be wrapped on a proxy, stores them in sorted order.
-pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
+pub(crate) fn find_methods_and_fields(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool {
// we need to find all the methods and fields for which we want to generate lua bindings
// we have to filter some out
// go through all impls on the types (traits and non-traits) and pick signatures we're happy with
// borrow checker fucky wucky
- let reflect_types = ctxt.reflect_types.keys().cloned().collect::>();
- for def_id in reflect_types {
- let adt_def = ctxt.tcx.adt_def(def_id);
-
- match adt_def.adt_kind() {
- AdtKind::Enum => {
- let strats = adt_def
- .variants()
- .iter()
- .flat_map(|variant| {
- if has_reflect_ignore_attr(ctxt.tcx.get_attrs_unchecked(variant.def_id)) {
- // TODO: is this the right approach? do we need to still include those variants? or do we just provide dummies
- // or can we just skip those ?
- info!(
- "ignoring enum variant: {}::{} due to 'reflect(ignore)' attribute",
- ctxt.tcx.item_name(def_id),
- variant.name
- );
- todo!();
- }
- 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::>();
+ // let mut reflect_types = std::mem::take(&mut ctxt.reflect_types);
+ let all_def_ids = ctxt.reflect_types.keys().cloned().collect::>();
+ for def_id in all_def_ids {
+ let (variants, excluded_variants) = generate_variants(ctxt, def_id);
- strats.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",
- ),
- _ => {}
- });
-
- let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap();
- ty_ctxt.variant_data = Some(adt_def);
- ty_ctxt.set_field_reflection_strategies(strats.into_iter());
- }
- AdtKind::Struct => {
- 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",
- ),
- _ => {}
- });
- let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap();
- assert!(ty_ctxt.variant_data.is_none(), "variant data already set!");
- ty_ctxt.variant_data = Some(adt_def);
- ty_ctxt.set_field_reflection_strategies(fields.into_iter());
- }
- t => panic!(
- "Unexpected item type, all `Reflect` implementing items should be enums or structs. : {t:?}"
- ),
- };
+ // filter the list of all methods and select candidates applicable to proxy generation
+ let mut all_impls = {
+ let trait_impls = &ctxt.reflect_types[&def_id].trait_impls;
- // borrow checker fucky wucky pt2
- let trait_impls_for_ty = {
- let ty_ctxt = ctxt.reflect_types.get(&def_id).unwrap();
- ty_ctxt.trait_impls.as_ref()
- .expect("A type was not processed correctly in a previous pass, missing trait impl info")
- .values()
+ ctxt.tcx
+ .inherent_impls(def_id)
+ .iter()
+ .chain(trait_impls.iter().flat_map(|(_, impl_did)| impl_did))
.cloned()
.collect::>()
};
- // should we not find functions set default value for future passes
- let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap();
- assert!(
- ty_ctxt.valid_functions.is_none(),
- "valid functions already set!"
- );
- ty_ctxt.valid_functions = Some(Vec::default());
-
- // filter the list of all methods and select candidates applicable to proxy generation
- let mut all_impls = ctxt
- .tcx
- .inherent_impls(def_id)
- .iter()
- .chain(trait_impls_for_ty.iter().flatten())
- .collect::>();
-
// sort them to avoid unnecessary diffs, we can use hashes here as they are forever stable (touch wood)
- all_impls.sort_by_cached_key(|a| ctxt.tcx.def_path_hash(**a));
+ all_impls.sort_by_cached_key(|a| ctxt.tcx.def_path_hash(*a));
for impl_did in all_impls {
- let functions = ctxt
+ let (functions, excluded_functions) = generate_functions(ctxt, args, def_id, impl_did);
+
+ let candidate = &mut ctxt.reflect_types[&def_id];
+ candidate.functions.extend(functions);
+ candidate.excluded_functions.extend(excluded_functions);
+ }
+ let candidate = &mut ctxt.reflect_types[&def_id];
+ candidate.variants.extend(variants);
+ candidate.excluded_variants.extend(excluded_variants);
+ }
+
+ if args.cmd.is_list_types() {
+ let stdout = std::io::stdout();
+ let mut handle = stdout.lock();
+
+ writeln!(
+ handle,
+ "included generation candidates in crate: {}",
+ ctxt.tcx.crate_name(LOCAL_CRATE)
+ )
+ .unwrap();
+ for (did, candidate) in ctxt.reflect_types.iter() {
+ writeln!(handle, "{:?}", ctxt.tcx.def_path_str(did)).unwrap();
+ writeln!(handle, "Exclusions: ").unwrap();
+ let mut annotator = AnnotationContextCollector::new(ctxt.tcx);
+ annotator.annotate(candidate);
+ let built = annotator.build();
+ for (ctxt, annotation) in built {
+ writeln!(handle, "{ctxt} : {annotation}").unwrap();
+ }
+ }
+ writeln!(
+ handle,
+ "excluded generation candidates in crate: {}",
+ ctxt.tcx.crate_name(LOCAL_CRATE)
+ )
+ .unwrap();
+ for candidate in ctxt.excluded_reflect_types.iter() {
+ if let Some(did) = candidate.did {
+ writeln!(handle, "{:?}", ctxt.tcx.def_path_str(did)).unwrap();
+ }
+ writeln!(handle, "Exclusions: ").unwrap();
+ let mut annotator = AnnotationContextCollector::new(ctxt.tcx);
+ annotator.annotate(candidate);
+ let built = annotator.build();
+ for (ctxt, annotation) in built {
+ writeln!(handle, "{ctxt} : {annotation}").unwrap();
+ }
+ }
+ return false;
+ }
+
+ true
+}
+
+fn generate_functions<'tcx>(
+ ctxt: &mut BevyCtxt<'tcx>,
+ args: &Args,
+ def_id: DefId,
+ impl_did: DefId,
+) -> (Vec>, Vec>) {
+ let (functions, excluded_functions): (Vec<_>, Vec<_>) = ctxt
+ .tcx
+ .associated_items(impl_did)
+ .in_definition_order()
+ .filter_map(|assoc_item| {
+ if !matches!(assoc_item.kind, AssocKind::Fn { .. }) {
+ return None;
+ }
+
+ let (fn_name, has_self) = match assoc_item.kind {
+ AssocKind::Fn { has_self, name } => (name, has_self),
+ _ => return None,
+ };
+
+ let trait_did = ctxt
.tcx
- .associated_items(impl_did)
- .in_definition_order()
- .filter_map(|assoc_item| {
- if !matches!(assoc_item.kind, AssocKind::Fn { .. }) {
- return None;
- }
+ .impl_opt_trait_ref(impl_did)
+ .map(|tr| tr.skip_binder().def_id);
+ let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id);
+ let fn_did = assoc_item.def_id;
+ let fn_sig = ctxt.tcx.fn_sig(fn_did).instantiate_identity();
+ let sig: FnSig = ctxt
+ .tcx
+ .normalize_erasing_late_bound_regions(param_env, fn_sig);
+ Some(FunctionCandidate {
+ fn_name,
+ did: fn_did,
+ visibility: assoc_item.visibility(ctxt.tcx),
+ sig,
+ has_self,
+ is_unsafe: sig.safety.is_unsafe(),
+ kind: trait_did
+ .map(|trait_did| FunctionCandidateKind::TraitImplMethod {trait_did,impl_did})
+ .unwrap_or(FunctionCandidateKind::Method { impl_did }),
+ notes: vec![],
+ arguments: vec![],
+ ret: FunctionArgCandidate::new(String::from("Return value")),
+ })
+ })
+ .map(|mut fn_candidate| {
- let (fn_name, has_self) = match assoc_item.kind {
- AssocKind::Fn { has_self, name } => (name, has_self),
- _ => return None,
- };
-
- let trait_did = ctxt
- .tcx
- .impl_trait_ref(*impl_did)
- .map(|tr| tr.skip_binder().def_id);
- let trait_name = trait_did
- .map(|td| ctxt.tcx.item_name(td).to_ident_string())
- .unwrap_or_else(|| "None".to_string());
-
- let fn_name = fn_name.to_ident_string();
- let fn_did = assoc_item.def_id;
-
- trace!(
- "Processing function: '{fn_name}' on type: `{}` on trait: `{trait_name}`",
- ctxt.tcx.item_name(def_id)
- );
-
- let param_env = TypingEnv::non_body_analysis(ctxt.tcx, def_id);
- let fn_sig = ctxt.tcx.fn_sig(fn_did).instantiate_identity();
- let sig: FnSig = ctxt
- .tcx
- .normalize_erasing_late_bound_regions(param_env, fn_sig);
-
- let function_generics = get_function_generics(ctxt.tcx, fn_did, *impl_did);
-
- if !function_generics.is_empty() {
- log::debug!(
- "Skipping function: `{}` on type: `{}` as it has generics: {:?}",
- fn_name,
- ctxt.tcx.item_name(def_id),
- function_generics
- );
- return None;
- }
+ if !fn_candidate.visibility.is_public() {
+ return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(String::from("function is not public"))))
+ }
- if let Some(unstability) = ctxt.tcx.lookup_stability(fn_did)
- && unstability.is_unstable()
- {
- log::debug!(
- "Skipping unstable function: `{}` on type: `{}` feature: {:?}",
- ctxt.tcx.item_name(fn_did),
- ctxt.tcx.item_name(def_id),
- unstability.feature.as_str()
- );
- return None;
- };
-
- let is_unsafe = sig.safety == Safety::Unsafe;
-
- if trait_did.is_none() && !ctxt.tcx.visibility(fn_did).is_public() {
- log::info!(
- "Skipping non-public function: `{}` on type: `{}`",
- fn_name,
- ctxt.tcx.item_name(def_id)
- );
- return None;
- }
+ let function_generics =
+ get_function_generics(ctxt.tcx, fn_candidate.did, fn_candidate.kind.impl_did());
- let arg_names = ctxt.tcx.fn_arg_idents(fn_did);
+ if !function_generics.is_empty() {
+ return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(format!(
+ "function has generics: {function_generics:?}"
+ ))));
+ }
- let mut reflection_strategies = Vec::with_capacity(sig.inputs().len());
- for (idx, arg_ty) in sig.inputs().iter().enumerate() {
- if type_is_supported_as_non_proxy_arg(
- ctxt.tcx,
- param_env,
- &ctxt.cached_traits,
- *arg_ty,
- ) {
- reflection_strategies.push(ReflectionStrategy::Primitive);
- } else if type_is_supported_as_proxy_arg(
- ctxt.tcx,
- &ctxt.reflect_types,
- &ctxt.meta_loader,
- *arg_ty,
- ) {
- reflection_strategies.push(ReflectionStrategy::Proxy);
- } else {
- report_fn_arg_not_supported(
- ctxt.tcx,
- fn_did,
- def_id,
- *arg_ty,
- &format!(
- "argument \"{:?}\" at idx {idx} not supported",
- arg_names[idx]
- ),
- );
- return None;
- }
+ let stability = ctxt.tcx.lookup_stability(fn_candidate.did);
+ let is_stable_for_target = stability
+ .map(|stability| match stability.stable_since() {
+ Some(StableSince::Version(rustc_version)) => {
+ !args.rustc_version_is_greater_than_mrsv_target(rustc_version)
}
+ _ => false,
+ })
+ .unwrap_or(true);
+
+ if !is_stable_for_target {
+ return Err(fn_candidate.with_note(GenerationExclusionNote::Reason(format!(
+ "function is not stable for the target: {:?} or unstable. Item stability: {stability:?}",
+ args.mrsv_target()
+ ))));
+ }
+
+ if fn_candidate.is_unsafe {
+
+ return Err(fn_candidate.with_note(GenerationExclusionNote::Reason("Function is unsafe".to_string())))
+ }
+
+ if matches!(fn_candidate.kind, FunctionCandidateKind::TraitImplMethod { .. }) && !ctxt.tcx.visibility(fn_candidate.did).is_public() {
+ return Err(fn_candidate.with_note(GenerationExclusionNote::Reason("Function is not public and does not come from a trait impl".to_string())));
+ }
+
+
+ let arg_names = ctxt.tcx.fn_arg_idents(fn_candidate.did);
+ fn_candidate.arguments = fn_candidate.sig.inputs().iter().zip(arg_names).enumerate().map(|(index, (arg_ty, ident))| {
+ let candidate_input = FunctionArgCandidate::new(ident.map(|id| id.to_string()).unwrap_or(index.to_string()));
+
+ let alternative_type = wrap_non_primtiives(*arg_ty, ctxt.tcx, &ctxt.cached_traits.bms_types);
+ let supported_as_primitive = alternative_type.implements_from_script(
+ alternative_type,
+ &ctxt.cached_traits.bms_types,
+ ctxt.tcx
+ );
+
+ match supported_as_primitive {
+ Ok(_) => candidate_input.with_reflection_strategy(ReflectionStrategy::Primitive),
+ Err(e1) => candidate_input
+ .with_note(GenerationExclusionNote::Reason("argument is neither a primitive type implementing FromScript or a reflectable type".to_string()))
+ .with_note(e1)
+ }
+ }).collect::>();
+
+ let alternative_type = wrap_non_primtiives(fn_candidate.sig.output(), ctxt.tcx, &ctxt.cached_traits.bms_types);
+ let supported_as_primitive = alternative_type.implements_into_script(
+ alternative_type,
+ &ctxt.cached_traits.bms_types,
+ ctxt.tcx
+ );
+ fn_candidate.ret = match supported_as_primitive {
+ Ok(_) => fn_candidate.ret.with_reflection_strategy(ReflectionStrategy::Primitive),
+ Err(e1) => fn_candidate.ret
+ .with_note(GenerationExclusionNote::Reason("return type is neither a primitive type implementing IntoScript or a reflectable type".to_string()))
+ .with_note(e1)
+ };
+
+
+ if fn_candidate.applying_notes().next().is_some() {
+ // notes inside will suffice here
+ return Err(fn_candidate);
+ }
+
+ Ok(fn_candidate)
+ })
+ .partition_result();
+ (functions, excluded_functions)
+}
+
+fn generate_variants<'tcx>(
+ ctxt: &mut BevyCtxt<'tcx>,
+ did: DefId,
+) -> (Vec>, Vec>) {
+ let candidate = &ctxt.reflect_types[&did];
+ let (mut variants, excluded_variants): (Vec<_>, Vec<_>) = candidate
+ .def
+ .variants()
+ .iter()
+ .map(|variant| {
+ let variant_candidate = VariantCandidate::new(variant);
+ if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(variant.def_id)) {
+ return Err(variant_candidate.with_note(GenerationExclusionNote::Reason(
+ "variant has 'reflect(ignore)' attribute".to_string(),
+ )));
+ }
+
+ Ok(variant_candidate)
+ })
+ .partition_result();
+
+ for variant in &mut variants {
+ let param_env = TypingEnv::non_body_analysis(ctxt.tcx, variant.def.def_id);
- if type_is_supported_as_non_proxy_return_val(
+ let (fields, excluded_fields): (Vec<_>, Vec<_>) = variant
+ .def
+ .fields
+ .iter()
+ .map(|field| {
+ let candidate = FieldCandidate::new(field);
+ let visibility = field.vis;
+ if !visibility.is_public() {
+ return Err(candidate.with_note(GenerationExclusionNote::Reason(format!(
+ "field is not public {:?}",
+ field.did
+ ))));
+ }
+
+ if has_reflect_ignore_attr(ctxt.tcx.get_all_attrs(field.did)) {
+ return Err(candidate.with_note(GenerationExclusionNote::Reason(
+ "field has 'reflect(ignore)' attribute".to_string(),
+ )));
+ }
+
+ let field_ty = ctxt.tcx.erase_and_anonymize_regions(
+ ctxt.tcx.type_of(field.did).instantiate_identity(),
+ );
+
+ Ok(
+ if type_is_supported_as_non_proxy_arg(
ctxt.tcx,
param_env,
&ctxt.cached_traits,
- sig.output(),
- ) {
- reflection_strategies.push(ReflectionStrategy::Primitive);
- } else if type_is_supported_as_proxy_return_val(
+ field_ty,
+ )
+ .is_ok()
+ && type_is_supported_as_non_proxy_return_val(
+ ctxt.tcx,
+ param_env,
+ &ctxt.cached_traits,
+ field_ty,
+ )
+ .is_ok()
+ {
+ candidate.with_reflection_strategy(ReflectionStrategy::Primitive)
+ } else if type_is_supported_as_proxy_arg(
ctxt.tcx,
&ctxt.reflect_types,
&ctxt.meta_loader,
- sig.output(),
- ) {
- reflection_strategies.push(ReflectionStrategy::Proxy);
- } else {
- report_fn_arg_not_supported(
+ field_ty,
+ )
+ .is_ok()
+ && type_is_supported_as_proxy_return_val(
ctxt.tcx,
- fn_did,
- def_id,
- sig.output(),
- "return value not supported",
- );
- return None;
- }
-
- Some(FunctionContext {
- is_unsafe,
- def_id: fn_did,
- has_self,
- trait_and_impl_did: trait_did.map(|td| (td, *impl_did)),
- reflection_strategies,
- })
- })
- .collect::>();
+ &ctxt.reflect_types,
+ &ctxt.meta_loader,
+ field_ty,
+ )
+ .is_ok()
+ {
+ candidate.with_reflection_strategy(ReflectionStrategy::Proxy)
+ } else {
+ candidate.with_reflection_strategy(ReflectionStrategy::Reflection)
+ },
+ )
+ })
+ .partition_result();
- let ty_ctxt = ctxt.reflect_types.get_mut(&def_id).unwrap();
- // must exist since we set default above
- ty_ctxt.valid_functions.as_mut().unwrap().extend(functions);
- }
+ variant.fields.extend(fields);
+ variant.excluded_fields.extend(excluded_fields);
}
-
- true
+ (variants, excluded_variants)
}
fn get_function_generics(tcx: TyCtxt, fn_did: DefId, impl_did: DefId) -> Vec {
@@ -308,74 +345,6 @@ fn get_function_generics(tcx: TyCtxt, fn_did: DefId, impl_did: DefId) -> Vec
.collect::>()
}
-fn report_fn_arg_not_supported(tcx: TyCtxt, f_did: DefId, type_did: DefId, ty: Ty, reason: &str) {
- info!(
- "Ignoring function: `{}` on type: `{}` reason: `{}`, relevant type: `{}`",
- tcx.item_name(f_did),
- tcx.item_name(type_did),
- reason,
- ty
- );
-}
-
-fn report_field_not_supported(
- tcx: TyCtxt,
- f_did: DefId,
- type_did: DefId,
- variant_did: Option,
- reason: &'static str,
-) {
- 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),
- normalised_ty,
- tcx.item_name(type_did),
- tcx.item_name(variant_did.unwrap_or(type_did)),
- reason
- );
-}
-
-/// Checks each field individually and returns reflection strategies
-fn process_fields<'tcx, 'f, I: Iterator
- >(
- tcx: TyCtxt<'tcx>,
- meta_loader: &MetaLoader,
- reflect_types: &IndexMap>,
- cached_traits: &CachedTraits,
- fields: I,
- param_env: TypingEnv<'tcx>,
-) -> Vec<(DefId, ReflectionStrategy)> {
- fields
- .map(move |f| {
- if !f.vis.is_public() {
- return (f.did, crate::ReflectionStrategy::Filtered);
- }
-
- let field_ty = tcx.erase_regions(tcx.type_of(f.did).instantiate_identity());
- if type_is_supported_as_non_proxy_arg(tcx, param_env, cached_traits, field_ty)
- && type_is_supported_as_non_proxy_return_val(
- tcx,
- param_env,
- cached_traits,
- field_ty,
- )
- {
- (f.did, crate::ReflectionStrategy::Primitive)
- } else if type_is_supported_as_proxy_arg(tcx, reflect_types, meta_loader, field_ty)
- && type_is_supported_as_proxy_return_val(tcx, reflect_types, meta_loader, field_ty)
- {
- (f.did, crate::ReflectionStrategy::Proxy)
- } else if !has_reflect_ignore_attr(tcx.get_attrs_unchecked(f.did)) {
- (f.did, crate::ReflectionStrategy::Reflection)
- } else {
- (f.did, crate::ReflectionStrategy::Filtered)
- }
- })
- .collect::>()
-}
-
/// Checks if the given attributes contain among them a reflect ignore attribute
fn has_reflect_ignore_attr(attrs: &[rustc_hir::Attribute]) -> bool {
attrs.iter().any(|a| {
@@ -389,10 +358,10 @@ fn has_reflect_ignore_attr(attrs: &[rustc_hir::Attribute]) -> bool {
/// Returns true if this type can be used in argument position by checking if it's a top level proxy arg
fn type_is_supported_as_proxy_arg<'tcx>(
tcx: TyCtxt<'tcx>,
- reflect_types: &IndexMap>,
+ reflect_types: &IndexMap>>,
meta_loader: &MetaLoader,
ty: Ty,
-) -> bool {
+) -> Result<(), GenerationExclusionNote> {
log::trace!("Checking type is supported as proxy arg: '{ty}'");
// nested references are not allowed for now
@@ -409,10 +378,10 @@ fn peel_refs_up_to_once(ty: Ty) -> Ty {
/// Returns true if this type can be used in return position by checking if it's a top level proxy arg without references
fn type_is_supported_as_proxy_return_val<'tcx>(
tcx: TyCtxt<'tcx>,
- reflect_types: &IndexMap>,
+ reflect_types: &IndexMap>>,
meta_loader: &MetaLoader,
ty: Ty,
-) -> bool {
+) -> Result<(), GenerationExclusionNote> {
log::trace!("Checking type is supported as proxy return val: '{ty}'");
type_is_adt_and_reflectable(tcx, reflect_types, meta_loader, ty)
}
@@ -420,79 +389,83 @@ fn type_is_supported_as_proxy_return_val<'tcx>(
/// Check if the type is an ADT and is reflectable (i.e. a proxy is being generated for it in SOME crate that we know about from the meta files)
fn type_is_adt_and_reflectable<'tcx>(
tcx: TyCtxt<'tcx>,
- reflect_types: &IndexMap>,
+ reflect_types: &IndexMap>>,
meta_loader: &MetaLoader,
ty: Ty,
-) -> bool {
- ty.ty_adt_def().is_some_and(|adt_def| {
+) -> Result<(), GenerationExclusionNote> {
+ let adt_def = match ty.ty_adt_def() {
+ Some(v) => v,
+ None => {
+ return Err(GenerationExclusionNote::Reason(format!(
+ "Type is not an ADT: {ty}",
+ )));
+ }
+ };
- let did = adt_def.did();
+ let did = adt_def.did();
- // even though our meta might already be written at this point, we use this as a quick out
- if reflect_types.contains_key(&did) {
- // local types are easy to check
- return true;
- }
+ // even though our meta might already be written at this point, we use this as a quick out
+ if reflect_types.contains_key(&did) {
+ // local types are easy to check
+ return Ok(());
+ }
- // for other crates, reach for meta data
- // we know a reflect impl can ONLY exist in one of two places due to orphan rules:
- // 1) the bevy_reflect crate
- // 2) the crate that defines the type
- // so search for these metas!
- let crate_name = tcx.crate_name(did.krate).to_ident_string();
+ // for other crates, reach for meta data
+ // we know a reflect impl can ONLY exist in one of two places due to orphan rules:
+ // 1) the bevy_reflect crate
+ // 2) the crate that defines the type
+ // so search for these metas!
+ let crate_name = tcx.crate_name(did.krate).to_ident_string();
+
+ let contains_hash = meta_loader.one_of_meta_files_contains(
+ &[&crate_name, "bevy_reflect"],
+ Some(&tcx.crate_name(LOCAL_CRATE).to_ident_string()),
+ tcx.def_path_hash(did),
+ );
- let contains_hash = meta_loader.one_of_meta_files_contains(
- &[&crate_name, "bevy_reflect"],
- Some(&tcx.crate_name(LOCAL_CRATE).to_ident_string()),
+ if !contains_hash {
+ return Err(GenerationExclusionNote::Reason(format!(
+ "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),
- );
-
- 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
- })
+ Ok(())
}
/// 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: TypingEnv<'tcx>,
- cached_traits: &CachedTraits,
+ cached_traits: &CachedItems,
ty: Ty<'tcx>,
-) -> bool {
+) -> Result<(), GenerationExclusionNote> {
trace!("Checking type is supported as non proxy arg: '{ty:?}' with param_env: '{param_env:?}'");
- impls_trait(tcx, param_env, ty, cached_traits.bms_from_script.unwrap())
+ impls_trait(tcx, param_env, ty, cached_traits.bms_types.from_script)
}
/// 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: TypingEnv<'tcx>,
- cached_traits: &CachedTraits,
+ cached_traits: &CachedItems,
ty: Ty<'tcx>,
-) -> bool {
+) -> Result<(), GenerationExclusionNote> {
trace!(
"Checkign type is supported as non proxy return val: '{ty:?}' with param_env: '{param_env:?}'"
);
if let TyKind::Ref(region, _, _) = ty.kind()
- && region.get_name().is_none_or(|rn| rn.as_str() != "'static")
+ && region
+ .get_name(tcx)
+ .is_none_or(|rn| rn.as_str() != "'static")
{
- return false;
+ return Err(GenerationExclusionNote::Reason(format!(
+ "{ty} cannot be used as a return value. References are not supported as return values.",
+ )));
}
- impls_trait(tcx, param_env, ty, cached_traits.bms_into_script.unwrap())
+ impls_trait(tcx, param_env, ty, cached_traits.bms_types.into_script)
}
pub(crate) fn impls_trait<'tcx>(
@@ -500,9 +473,93 @@ pub(crate) fn impls_trait<'tcx>(
param_env: TypingEnv<'tcx>,
ty: Ty<'tcx>,
trait_did: DefId,
-) -> bool {
- tcx.infer_ctxt()
+) -> Result<(), GenerationExclusionNote> {
+
+
+ if tcx
+ .infer_ctxt()
.build(param_env.typing_mode)
.type_implements_trait(trait_did, [ty], param_env.param_env)
.must_apply_modulo_regions()
+ {
+ Ok(())
+ } else {
+ let failure = debug_trait_impl_failure(tcx, param_env, trait_did, [ty].into_iter());
+ Err(GenerationExclusionNote::Reason(format!(
+ "type {ty}, does not implement the trait {}. {}",
+ tcx.item_name(trait_did),
+ failure.unwrap_err()
+ )))
+ }
}
+
+pub fn debug_trait_impl_failure<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ param_env: TypingEnv<'tcx>,
+ trait_def: DefId,
+ trait_params: impl Iterator
- >,
+) -> Result<(), String> {
+ // let trait_generics = tcx.generics_of(trait_def);
+
+ let params = trait_params.collect::>();
+
+ // if params.len() != trait_generics.count() {
+ // panic!("Expected generics for trait {:?}", trait_generics);
+ // }
+
+ // 1) Build a trait ref for trait_def
+ // Use tcx.mk_trait_ref if present, otherwise create the TraitRef directly.
+ // let trait_args = tcx.mk_args(&[GenericArg::from(ty_to_check)]);
+ let trait_ref = ty::TraitRef::new(tcx, trait_def, params);
+
+ // 2) Convert to a predicate (poly trait predicate)
+ // Some rustc versions allow: let pred = ty::Binder::dummy(trait_ref).to_predicate(tcx);
+ // If `to_predicate` is not found on Binder in your toolchain, use:
+ // let poly_trait_pred = ty::Binder::dummy(trait_ref);
+ // let predicate: Predicate<'tcx> = trait_ref.upcast(tcx); // <- if this errors, see notes below
+ // let obligation = traits::Obligation {
+ // cause: traits::ObligationCause::dummy(),
+ // param_env,
+ // recursion_depth: 0,
+ // predicate: trait_ref.upcast(self.tcx),
+ // };
+ // 3) Build an obligation
+ let cause = ObligationCause::dummy();
+ let obligation = Obligation::new(tcx, cause, param_env.param_env, trait_ref);
+
+ // 4) Create an infer context and selection machinery
+ // The build(...) call needs a `typing_mode` argument in some versions.
+ // Use your existing typing_mode (you should have it alongside param_env).
+ let infcx = tcx.infer_ctxt().build(param_env.typing_mode);
+
+ // Create an obligation context (fulfillment/selection helper)
+ // In some versions this is `ObligationCtxt::new(&infcx)`, in others `ObligationCtxt::new_infer(&infcx)`.
+ let ocx = ObligationCtxt::new(&infcx);
+
+ // Register the obligation and try to select/fulfill.
+ ocx.register_obligation(obligation);
+
+ // This will attempt all obligation selection and return any errors (empty vec == ok)
+ // API name may be `select_all_or_error`, `select_all_or_error(&mut infcx)`, or
+ // `select_all_or_error(&infcx)` depending on version. Try the no-arg one first.
+ let errors = ocx.evaluate_obligations_error_on_ambiguity();
+ if errors.is_empty() {
+ return Ok(());
+ }
+
+ // If there are errors, gather text + nested obligations for debugging
+ let mut msgs = Vec::new();
+ for err in errors {
+ // FulfillmentError (or FulfillmentErrorCode) pretty-printers vary; we stringify:
+ msgs.push(format!("fulfillment error: {:#?}", err));
+ }
+
+ // Also dump any nested obligations from the obligation stack if possible:
+ // (some APIs expose ocx.fulfillment_cx or ocx.infcx; if not available, skip)
+
+ // This is version-dependent; if not present, ignore.
+ // msgs.push(format!("fulfillment_cx: {:#?}", ocx.infcx.));
+
+
+ Err(msgs.join("\n"))
+}
\ No newline at end of file
diff --git a/codegen/src/passes/find_reflect_types.rs b/codegen/src/passes/find_reflect_types.rs
index 74a55642bd..1b7f25e2d5 100644
--- a/codegen/src/passes/find_reflect_types.rs
+++ b/codegen/src/passes/find_reflect_types.rs
@@ -1,73 +1,137 @@
-use log::{debug, info};
+use itertools::Itertools;
use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_middle::ty::AdtDef;
-use crate::{Args, BevyCtxt, DEF_PATHS_REFLECT, ReflectType};
+use crate::{
+ Args, BevyCtxt,
+ candidate::{Annotated, GenerationCandidate, GenerationExclusionNote},
+};
/// Finds all reflect types which we can wrap in the crate as well as sorts the final list.
pub(crate) fn find_reflect_types(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bool {
let tcx = &ctxt.tcx;
let ignored_types = match &args.cmd {
crate::Command::Generate { ignored_types, .. } => ignored_types,
+ crate::Command::ListTypes => &vec![],
_ => return true,
};
- for trait_did in tcx.all_local_trait_impls(()).keys() {
- // we want to find the canonical `Reflect` trait's implemenations across crates, so let's check all impls and choose those
- // whose def_path is equal to what we know the Reflect trait's is
+ let reflect_ref = ctxt.cached_traits.bevy_types.reflect;
+ let reflect_impls = tcx.trait_impls_of(reflect_ref);
+ // let sess = ctxt.tcx.sess;
+ // let source_map = sess.source_map();
+ // log::info!(
+ // "found impls: {:?}",
+ // reflect_impls.non_blanket_impls().iter().map(|impl_| sess
+ // .source_map()
+ // .span_to_location_info(ctxt.tcx.def_span(impl_.)))
+ // );
- let def_path_str = tcx.def_path_str(trait_did);
-
- if !DEF_PATHS_REFLECT.contains(&def_path_str.as_str()) {
- continue;
- }
-
- debug!(
- "Found Reflect impls in crate: {}, with path: {}",
- tcx.crate_name(LOCAL_CRATE),
- def_path_str
- );
-
- // this returns non-local impls as well
- let reflect_trait_impls = tcx.trait_impls_of(trait_did);
-
- // blanket impls are implementations on generics directly, i.e. `impl From for T`
- // non blanket impls may also contain generics but those will be contained within another type i.e. `impl Default for Vec`
- // ignore anything with a generic, so blanket_impls are out for now
- // we also make sure to only work over types and impls directly in the local crate
- let reflect_adts_did = reflect_trait_impls
+ // blanket impls are implementations on generics directly, i.e. `impl From for T`
+ // non blanket impls may also contain generics but those will be contained within another type i.e. `impl Default for Vec`
+ // ignore anything with a generic, so blanket_impls are out for now
+ // we also make sure to only work over types and impls directly in the local crate
+ // log::info!(
+ // "reflect_crate: {:?}, {:?}",
+ // ctxt.cached_traits.bevy_types.reflect_crate,
+ // ctxt.tcx
+ // .def_path(ctxt.cached_traits.bevy_types.reflect_crate.as_def_id())
+ // );
+ // log::info!(
+ // "local_crate: {:?}, {:?}",
+ // ctxt.cached_traits.bevy_types.reflect_crate,
+ // ctxt.tcx.def_path(LOCAL_CRATE.as_def_id())
+ // );
+ let (reflect_adts_did, excluded_candidates): (Vec<_>, Vec<_>) =
+ reflect_impls
.non_blanket_impls()
.iter()
.flat_map(|(self_ty, impl_dids)| impl_dids.iter().zip(std::iter::repeat(self_ty)))
- .filter_map(|(impl_did, self_ty)| {
+ // .inspect(|(impl_did, _)| {
+ // log::info!(
+ // "in crate: {LOCAL_CRATE:?}, found impl: \n{impl_did:?}\n{:?}\nis_local: {}\n",
+ // source_map.span_to_diagnostic_string(tcx.def_span(*impl_did)),
+ // impl_did.is_local()
+ // )
+ // })
+ // non local impls are not relevant, we only care about what a crate implements, we don't want to include in the excluded set either, as these aren't even considered
+ .filter(|(impl_did, _)| impl_did.is_local())
+ .map(|(impl_did, self_ty)| {
+ let mut early_candidate = GenerationCandidate::>::default();
+
+ let did = match self_ty.def() {
+ Some(ty) => ty,
+ None => {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ format!("impl block {impl_did:?}, has no self type"),
+ )));
+ }
+ };
+
+ early_candidate.did = Some(did);
+
let generics = tcx.generics_of(*impl_did);
- (impl_did.is_local() &&
+ if generics.count() > 0 {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ format!("impl block {impl_did:?}, has generics"),
+ )));
+ }
+
// only non parametrized simple types are allowed, i.e. "MyStruct" is allowed but "MyStruct" isn't
- generics.count() == 0 &&
- self_ty.def().is_some_and(|did| {
- let short_form = format!("{}::{}",ctxt.tcx.crate_name(LOCAL_CRATE),ctxt.tcx.item_name(did));
- if ignored_types.contains(&short_form) || ignored_types.contains(&tcx.def_path_str(did)) { info!("Ignoring type: {:?}", tcx.def_path_str(did));
- return false;
- };
- let adt_generics = tcx.generics_of(did);
- tcx.visibility(did).is_public() && adt_generics.count() == 0
- }))
- .then(|| self_ty.def().unwrap())
- })
- .inspect(|impl_| debug!("On type: {:?}", tcx.item_name(*impl_)))
- .map(|did| (did, ReflectType::default()));
+ let short_form = format!(
+ "{}::{}",
+ ctxt.tcx.crate_name(LOCAL_CRATE),
+ ctxt.tcx.item_name(did)
+ );
- ctxt.reflect_types.extend(reflect_adts_did);
- }
+ if ignored_types.contains(&short_form)
+ || ignored_types.contains(&tcx.def_path_str(did))
+ {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ format!("type {short_form} explicitly excluded by user"),
+ )));
+ };
+
+ let adt_generics = tcx.generics_of(did);
+
+ if adt_generics.count() > 0 {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ format!("type has generics: {adt_generics:?}"),
+ )));
+ }
+
+ let visibility = tcx.visibility(did);
+ if !visibility.is_public() {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ format!("type has non-public visibility: {visibility:?}"),
+ )));
+ }
+
+ if ctxt
+ .path_finder
+ .find_import_paths_no_fallback(did)
+ .is_none()
+ && did.is_local()
+ {
+ return Err(early_candidate.with_note(GenerationExclusionNote::Reason(
+ "type is local and has no public import paths".to_string(),
+ )));
+ }
+
+ let adt = ctxt.tcx.adt_def(did);
+
+ Ok(early_candidate.promote(adt))
+ })
+ .partition_result();
+ ctxt.reflect_types
+ .extend(reflect_adts_did.into_iter().map(|a| (a.def.did(), a)));
+ ctxt.excluded_reflect_types.extend(excluded_candidates);
ctxt.reflect_types
.sort_by_cached_key(|did, _| tcx.item_name(*did));
- if args.cmd.is_list_types() {
- for did in ctxt.reflect_types.keys() {
- println!("{:?}", tcx.def_path_str(did));
- }
- return false;
- }
+ log::debug!("Found: {} types", ctxt.reflect_types.len());
+ log::debug!("Excluded: {} types", ctxt.excluded_reflect_types.len());
true
}
diff --git a/codegen/src/passes/find_trait_impls.rs b/codegen/src/passes/find_trait_impls.rs
index 1d33232bb7..dda4ef6c61 100644
--- a/codegen/src/passes/find_trait_impls.rs
+++ b/codegen/src/passes/find_trait_impls.rs
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-
use log::trace;
use rustc_hir::def_id::DefId;
use rustc_infer::{
@@ -33,13 +31,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.bms_from_script.unwrap(),
+ ctxt.cached_traits.bms_types.from_script,
reflect_ty_did,
)
.is_empty()
|| type_impl_of_trait(
tcx,
- ctxt.cached_traits.bms_into_script.unwrap(),
+ ctxt.cached_traits.bms_types.into_script,
reflect_ty_did,
)
.is_empty();
@@ -79,8 +77,7 @@ pub(crate) fn find_trait_impls(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
}
}
- assert!(type_ctxt.trait_impls.is_none(), "trait impls already set!");
- type_ctxt.trait_impls = Some(HashMap::from_iter(impls));
+ type_ctxt.trait_impls.extend(impls);
}
true
}
@@ -146,10 +143,7 @@ fn impl_matches<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, impl_def_id: DefId)
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
- .impl_trait_ref(impl_def_id)
- .expect("Expected defid to be an impl for a trait")
- .instantiate(tcx, impl_args);
+ let impl_trait_ref = tcx.impl_trait_ref(impl_def_id).instantiate(tcx, impl_args);
let impl_trait_ref = ocx.normalize(&ObligationCause::dummy(), param_env, impl_trait_ref);
let impl_trait_ref_ty = impl_trait_ref.self_ty();
if ocx
@@ -164,7 +158,7 @@ fn impl_matches<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, impl_def_id: DefId)
Obligation::new(tcx, ObligationCause::dummy(), param_env, predicate)
}));
- ocx.select_where_possible().is_empty()
+ ocx.try_evaluate_obligations().is_empty()
};
infcx.probe(|_| impl_may_apply(impl_def_id))
diff --git a/codegen/src/passes/mod.rs b/codegen/src/passes/mod.rs
index 43dc5738a7..af99d799db 100644
--- a/codegen/src/passes/mod.rs
+++ b/codegen/src/passes/mod.rs
@@ -1,6 +1,6 @@
use crate::{Args, BevyCtxt};
-mod cache_traits;
+mod cache_items;
mod codegen;
mod crawl_paths;
mod find_methods_and_fields;
@@ -28,10 +28,10 @@ pub(crate) const FIND_METHODS_AND_FIELDS: Pass = Pass {
cb: find_methods_and_fields::find_methods_and_fields,
};
-pub(crate) const CACHE_TRAITS: Pass = Pass {
- name: "Cache traits",
- description: "Searching for necessary traits",
- cb: cache_traits::cache_traits,
+pub(crate) const CACHE_ITEMS: Pass = Pass {
+ name: "Cache items",
+ description: "Searching for necessary traits and items",
+ cb: cache_items::cache_items,
};
pub(crate) const WRITE_META: Pass = Pass {
@@ -65,12 +65,12 @@ pub(crate) const CRAWL_PATHS: Pass = Pass {
};
pub(crate) const ALL_PASSES: [Pass; 8] = [
- CACHE_TRAITS,
+ CACHE_ITEMS,
+ CRAWL_PATHS, // paths needed in the reflect type finder step
FIND_REFLECT_TYPES,
FIND_TRAIT_IMPLS, // we have to do this before meta as we still filter some things here
WRITE_META, // the earlier this happens the better, as other crates will depend on our meta files but not the rest of the passes!
FIND_METHODS_AND_FIELDS,
- CRAWL_PATHS,
POPULATE_TEMPLATE_DATA,
CODEGEN,
];
diff --git a/codegen/src/passes/populate_template_data.rs b/codegen/src/passes/populate_template_data.rs
index a56701c6c7..3c81a01f48 100644
--- a/codegen/src/passes/populate_template_data.rs
+++ b/codegen/src/passes/populate_template_data.rs
@@ -2,14 +2,12 @@ use std::{borrow::Cow, convert::identity, panic};
use log::{trace, warn};
use rustc_hir::def_id::{DefId, LOCAL_CRATE};
-use rustc_middle::ty::{
- AdtDef, FieldDef, GenericArg, GenericParamDefKind, TraitRef, Ty, TyKind, TypingEnv,
-};
+use rustc_middle::ty::{AdtDef, GenericArg, GenericParamDefKind, TraitRef, Ty, TyKind, TypingEnv};
use rustc_span::Symbol;
use crate::{
- Arg, Args, BevyCtxt, Field, Function, FunctionContext, Item, Output, ReflectType,
- TemplateContext, Variant,
+ Arg, Args, BevyCtxt, Field, Function, Item, Output, TemplateContext, Variant,
+ candidate::{FunctionCandidate, VariantCandidate},
};
/// Converts the BevyCtxt into simpler data that can be used in templates directly,
/// Clears the BevyCtxt by clearing data structures after it uses them.
@@ -23,11 +21,7 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo
let display_diagnostic = tcx.get_diagnostic_item(Symbol::intern("Display")).unwrap();
for (reflect_ty_did, ty_ctxt) in ctxt.reflect_types.drain(..).collect::>().into_iter() {
- let fn_ctxts = ty_ctxt
- .valid_functions
- .as_ref()
- .expect("Missing function context for a type, were all the passes run correctly?");
-
+ let fn_ctxts = &ty_ctxt.functions;
let has_static_methods = fn_ctxts.iter().any(|fn_ctxt| !fn_ctxt.has_self);
let mut functions = process_functions(ctxt, fn_ctxts);
@@ -45,24 +39,25 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo
)
});
- let variant = ty_ctxt.variant_data.as_ref().unwrap();
+ let def = &ty_ctxt.def;
- let is_tuple_struct = variant.is_struct()
- && variant
+ let is_tuple_struct = def.is_struct()
+ && def
.all_fields()
.next()
.is_some_and(|f| f.name.as_str().chars().all(|c| c.is_numeric()));
- let variants = variant
- .variants()
+ let variants = ty_ctxt
+ .variants
.iter()
.map(|variant| Variant {
- docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(variant.def_id)),
- name: variant.name.to_ident_string().into(),
- fields: process_fields(ctxt, variant.fields.iter(), &ty_ctxt),
+ docstrings: docstrings(ctxt.tcx.get_all_attrs(variant.def.def_id)),
+ name: variant.def.name.to_ident_string().into(),
+ fields: process_fields(ctxt, variant),
})
.collect::>();
- let trait_impls = ty_ctxt.trait_impls.as_ref().unwrap();
+
+ let trait_impls = ty_ctxt.trait_impls;
let item = Item {
ident: tcx.item_name(reflect_ty_did).to_ident_string(),
import_path: import_path(ctxt, reflect_ty_did),
@@ -71,7 +66,7 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo
is_enum: variants.len() > 1,
variants,
is_tuple_struct,
- docstrings: docstrings(tcx.get_attrs_unchecked(reflect_ty_did)),
+ docstrings: docstrings(tcx.get_all_attrs(reflect_ty_did)),
impls_clone: trait_impls.contains_key(&clone_diagnostic),
impls_debug: trait_impls.contains_key(&debug_diagnostic),
impls_display: trait_impls.contains_key(&display_diagnostic),
@@ -103,69 +98,70 @@ pub(crate) fn populate_template_data(ctxt: &mut BevyCtxt<'_>, args: &Args) -> bo
true
}
-pub(crate) fn process_fields<'f, I: Iterator
- >(
- ctxt: &BevyCtxt,
- fields: I,
- ty_ctxt: &ReflectType,
+pub(crate) fn process_fields<'ctx>(
+ ctxt: &BevyCtxt<'ctx>,
+ variant: &VariantCandidate<'ctx>,
) -> Vec {
- fields
+ variant
+ .fields
+ .iter()
.map(|field| Field {
- docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(field.did)),
+ docstrings: docstrings(ctxt.tcx.get_all_attrs(field.did)),
ident: field.name.to_ident_string(),
ty: ty_to_string(ctxt, ctxt.tcx.type_of(field.did).skip_binder(), false),
- reflection_strategy: *ty_ctxt
- .get_field_reflection_strat(field.did)
- .unwrap_or_else(|| panic!("{ty_ctxt:#?}")),
+ reflection_strategy: field.reflection_strategy,
})
.collect()
}
-pub(crate) fn process_functions(ctxt: &BevyCtxt, fns: &[FunctionContext]) -> Vec {
+pub(crate) fn process_functions<'tcx>(
+ ctxt: &BevyCtxt<'tcx>,
+ fns: &[FunctionCandidate<'tcx>],
+) -> Vec {
fns.iter()
.map(|fn_ctxt| {
- let fn_sig = ctxt.tcx.fn_sig(fn_ctxt.def_id).skip_binder().skip_binder();
let args = ctxt
.tcx
- .fn_arg_idents(fn_ctxt.def_id)
+ .fn_arg_idents(fn_ctxt.did)
.iter()
- .zip(fn_sig.inputs())
+ .zip(fn_ctxt.sig.inputs())
.enumerate()
.map(|(idx, (ident, ty))| {
let normalized_ty = ctxt.tcx.normalize_erasing_regions(
- TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id),
+ TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.did),
*ty,
);
Arg {
ident: ident.map(|s| s.to_string()).unwrap_or(format!("arg_{idx}")),
ty: ty_to_string(ctxt, normalized_ty, false),
proxy_ty: ty_to_string(ctxt, normalized_ty, true),
- reflection_strategy: fn_ctxt.reflection_strategies[idx],
+ reflection_strategy: fn_ctxt.arguments[idx].reflection_strategy,
}
})
.collect();
let out_ty = ctxt.tcx.normalize_erasing_regions(
- TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.def_id),
- fn_sig.output(),
+ TypingEnv::non_body_analysis(ctxt.tcx, fn_ctxt.did),
+ fn_ctxt.sig.output(),
);
let output = Output {
ty: ty_to_string(ctxt, out_ty, false),
proxy_ty: ty_to_string(ctxt, out_ty, true),
- reflection_strategy: *fn_ctxt.reflection_strategies.last().unwrap(),
+ reflection_strategy: fn_ctxt.ret.reflection_strategy,
};
let is_unsafe = fn_ctxt.is_unsafe;
Function {
is_unsafe,
- ident: ctxt.tcx.item_name(fn_ctxt.def_id).to_ident_string(),
+ ident: ctxt.tcx.item_name(fn_ctxt.did).to_ident_string(),
args,
output,
has_self: fn_ctxt.has_self,
- docstrings: docstrings(ctxt.tcx.get_attrs_unchecked(fn_ctxt.def_id)),
- from_trait_path: fn_ctxt.trait_and_impl_did.map(|(_, impl_did)| {
- let trait_ref = ctxt.tcx.impl_trait_ref(impl_did).unwrap().skip_binder();
+ docstrings: docstrings(ctxt.tcx.get_all_attrs(fn_ctxt.did)),
+ from_trait_path: fn_ctxt.kind.as_trait_fn().map(|(_, impl_did)| {
+ let trait_ref = ctxt.tcx.impl_trait_ref(impl_did).skip_binder();
trait_ref_to_string(ctxt, trait_ref)
}),
@@ -239,7 +235,7 @@ fn trait_ref_to_string<'tcx>(ctxt: &BevyCtxt<'tcx>, trait_ref: TraitRef<'tcx>) -
// filter out non const | type generics and the compiler generated ones
.filter(|(_, arg_def)| match arg_def.kind {
GenericParamDefKind::Lifetime => false,
- GenericParamDefKind::Const { synthetic, .. } => !synthetic,
+ GenericParamDefKind::Type { synthetic, .. } => !synthetic,
_ => true,
})
.map(|(arg, arg_def)| {
diff --git a/codegen/src/passes/write_meta.rs b/codegen/src/passes/write_meta.rs
index 1d478f2964..ae00ed6a92 100644
--- a/codegen/src/passes/write_meta.rs
+++ b/codegen/src/passes/write_meta.rs
@@ -51,7 +51,7 @@ pub(crate) fn write_meta(ctxt: &mut BevyCtxt<'_>, _args: &Args) -> bool {
k.to_string(),
Dependency {
version: d.version.to_string(),
- features: features.iter().map(|f| f.to_string()).collect(),
+ features: features.iter().map(|f| f.feature.to_string()).collect(),
},
),
None => todo!(),
diff --git a/codegen/src/plugin.rs b/codegen/src/plugin.rs
index 937c4db23d..043578c147 100644
--- a/codegen/src/plugin.rs
+++ b/codegen/src/plugin.rs
@@ -1,19 +1,36 @@
-use std::env;
+use std::{collections::HashMap, env, path::PathBuf};
-use cargo_metadata::camino::Utf8Path;
-use clap::Parser;
-use log::debug;
+use crate_feature_graph::WorkspaceGraph;
+use log::{debug, trace};
+use regex::Regex;
+use rustc_hir::def_id::LOCAL_CRATE;
+use serde::{Deserialize, Serialize};
+use tera::Context;
use crate::{
- BevyAnalyzerCallbacks, WorkspaceMeta,
- driver::{CrateFilter, RustcPluginArgs},
+ ALL_PASSES, Args, TemplateKind, WORKSPACE_GRAPH_FILE_ENV, WorkspaceMeta,
+ modifying_file_loader::ModifyingFileLoader,
};
-pub struct BevyAnalyzer;
-impl crate::driver::RustcPlugin for BevyAnalyzer {
- type Args = crate::Args;
+#[derive(Clone, Serialize, Deserialize)]
+pub struct Payload {
+ /// The rmeta for the bootstrapped reflect crate
+ pub bootstrap_deps_path: String,
+ pub bootstrap_rlibs: HashMap,
+ pub include_crates: Vec,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct BevyAnalyzer {
+ pub payload: Payload,
+ pub args: Args,
+}
+
+struct DefaultCallbacks;
+impl rustc_driver::Callbacks for DefaultCallbacks {}
- fn version(&self) -> std::borrow::Cow<'static, str> {
+impl crate::driver::RustcPlugin for BevyAnalyzer {
+ fn version() -> std::borrow::Cow<'static, str> {
env!("CARGO_PKG_VERSION").into()
}
@@ -21,36 +38,74 @@ impl crate::driver::RustcPlugin for BevyAnalyzer {
"bms-codegen-driver".into()
}
- fn args(&self, target_dir: &Utf8Path) -> RustcPluginArgs {
- debug!("Target dir: {target_dir}");
-
- RustcPluginArgs {
- args: crate::Args::parse_from(std::env::args().skip(1)),
- filter: CrateFilter::OnlyWorkspace,
+ fn run(
+ mut self,
+ crate_name: &str,
+ mut compiler_args: Vec,
+ is_not_build_invocation: bool,
+ ) {
+ // bootstrapped crates already have artifacts ready to inject
+ // we don't want to build these, it will only generate errors
+ let bootstrapped_crate = self.payload.bootstrap_rlibs.contains_key(crate_name);
+ if bootstrapped_crate {
+ return;
}
- }
- fn run(self, compiler_args: Vec, plugin_args: Self::Args) {
- let mut callbacks = BevyAnalyzerCallbacks::new(plugin_args);
+ let workspace_crate = self
+ .payload
+ .include_crates
+ .contains(&crate_name.to_string());
+
+ self.inject_bootstrapped_artifacts(&mut compiler_args);
+
+ // let active_features: Vec = compiler_args
+ // .windows(2)
+ // .filter_map(|w| {
+ // if w[0] == "--cfg" {
+ // let arg = &w[1];
+
+ // // Match --cfg feature="foo"
+ // if let Some(feat) = arg.strip_prefix("feature=") {
+ // // Trim quotes
+ // return Some(feat.trim_matches('"').to_string());
+ // }
+ // }
+ // None
+ // })
+ // .collect();
+
+ // log::trace!("Rustc received featuress: {}", active_features.join(", "));
- rustc_driver_impl::run_compiler(&compiler_args, &mut callbacks);
- log::trace!("Finished compiling with plugin");
+ // non-workspace crates can be run as normal without any analysis
+ // we don't care about these for now, but still need to modify externs to avoid errors, they need to compile fine
+ if is_not_build_invocation || !workspace_crate {
+ // for things like --print from cargo
+ log::info!("Analysing: {crate_name}");
+ rustc_driver_impl::run_compiler(&compiler_args, &mut DefaultCallbacks);
+ } else {
+ log::info!("Building: {crate_name}");
+ rustc_driver_impl::run_compiler(&compiler_args, &mut self);
+ }
}
- fn modify_cargo(&self, cmd: &mut std::process::Command, args: &Self::Args) {
+ fn modify_cargo(&self, cmd: &mut std::process::Command) {
*cmd = copy_command_without_args(cmd, &["-q", "-v", "--all", "--workspace"]);
cmd.args(["--color", "always"]);
- if !args.features.is_empty() {
- cmd.args(["--features", &args.features.join(",")]);
+ if !self.args.features.is_empty() {
+ log::info!(
+ "Running cargo with features: {}",
+ self.args.features.join(",")
+ );
+ cmd.args(["--features", &self.args.features.join(",")]);
}
- if args.no_default_features {
+ if self.args.no_default_features {
cmd.arg("--no-default-features");
}
// make cargo chatty as well
- if args.verbose.get_log_level_int() >= 3 {
- cmd.arg("-v");
+ if self.args.verbose.get_log_level_int() >= 3 {
+ cmd.arg("-vv");
} else {
cmd.arg("-q");
}
@@ -74,7 +129,52 @@ impl crate::driver::RustcPlugin for BevyAnalyzer {
.map(|a| a.to_string_lossy())
.collect::>()
.join(" ");
- log::debug!("Running: \n{all_env} {bin_name} {args}",);
+ log::debug!("Running cargo build command: \n{all_env} {bin_name} {args}",);
+ }
+
+ fn initialize_from_env() -> Self {
+ serde_json::from_str(&std::env::var(crate::PLUGIN_PAYLOAD).unwrap()).unwrap()
+ }
+
+ fn serialize_to_env(&self) {
+ unsafe { std::env::set_var(crate::PLUGIN_PAYLOAD, serde_json::to_string(&self).unwrap()) }
+ }
+}
+
+impl BevyAnalyzer {
+ fn inject_bootstrapped_artifacts(&self, compiler_args: &mut Vec) {
+ log::info!("args: {compiler_args:?}");
+ // we now modify externs before running anything via rustc
+ let regex =
+ Regex::new(r"(?P(?P(?:\./|/)?[A-Za-z0-9_\-./]*)?(?Plib(?P[A-Za-z0-9_]+)-(?P[A-Fa-f0-9]+)\.(rmeta|rlib)))").unwrap();
+
+ // inject deps directory as linking dir
+ compiler_args.extend([
+ String::from("-L"),
+ format!("dependency={}", self.payload.bootstrap_deps_path),
+ ]);
+
+ // replace existing externs, and if none are found
+ // inject
+ for (krate, rlib) in &self.payload.bootstrap_rlibs {
+ let mut replaced = false;
+ for arg in compiler_args.iter_mut() {
+ for matches in regex.captures_iter(&arg.to_string()) {
+ let rlib_krate = &matches["crate"];
+ if rlib_krate == krate {
+ let found_rlib = &matches["full"];
+ log::info!("replacing rlib {found_rlib} with {rlib} for crate {krate}");
+ *arg = arg.replace(found_rlib, rlib);
+ replaced = true;
+ }
+ }
+ }
+ if !replaced {
+ let new_args = [String::from("--extern"), format!("{krate}={rlib}")];
+ log::info!("injecting rlib for {krate}, injecting: {new_args:?}");
+ compiler_args.extend(new_args);
+ }
+ }
}
}
@@ -90,3 +190,97 @@ fn copy_command_without_args(
new_cmd.envs(cmd.get_envs().filter_map(|(a, b)| b.map(|b| (a, b))));
new_cmd
}
+
+impl rustc_driver::Callbacks for BevyAnalyzer {
+ fn after_expansion(
+ &mut self,
+ compiler: &rustc_interface::interface::Compiler,
+ tcx: rustc_middle::ty::TyCtxt<'_>,
+ ) -> rustc_driver::Compilation {
+ trace!("After expansion callback");
+
+ let sess = &compiler.sess;
+
+ if sess.dcx().has_errors().is_some() {
+ sess.dcx().fatal("compilation failed, aborting analysis.");
+ }
+
+ let mut meta_dirs = Vec::default();
+ let mut templates_dir = None;
+ // add all relevant meta dirs to the context
+ meta_dirs.push(self.args.output.to_owned());
+ if let crate::Command::Generate {
+ meta,
+ meta_output,
+ templates,
+ ..
+ } = &self.args.cmd
+ {
+ templates.clone_into(&mut templates_dir);
+ if let Some(meta_output) = meta_output {
+ meta_dirs.push(meta_output.to_owned())
+ };
+ meta.iter()
+ .flatten()
+ .for_each(|m| meta_dirs.push(m.to_owned()));
+ };
+
+ let include_private = match &self.args.cmd {
+ crate::Command::Generate {
+ include_private, ..
+ } => *include_private,
+ _ => false,
+ };
+
+ // tera environment for import processor
+ let tera = crate::configure_tera(tcx.crate_name(LOCAL_CRATE).as_str(), &templates_dir);
+
+ debug!("Using meta directories: {meta_dirs:?}");
+
+ let mut graph = WorkspaceGraph::deserialize(&PathBuf::from(
+ std::env::var(WORKSPACE_GRAPH_FILE_ENV).unwrap(),
+ ))
+ .unwrap();
+ graph.stable_sort();
+
+ 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()
+ })),
+ graph,
+ );
+
+ trace!("Running all passes");
+ for p in ALL_PASSES {
+ debug!(
+ "{}, 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");
+ }
+
+ log::info!(
+ "Analyzed crate: {} (found {} types)",
+ tcx.crate_name(LOCAL_CRATE),
+ ctxt.reflect_types.len(),
+ );
+
+ rustc_driver::Compilation::Continue
+ }
+
+ fn config(&mut self, config: &mut rustc_interface::interface::Config) {
+ config.file_loader = Some(Box::new(ModifyingFileLoader));
+ }
+}
diff --git a/codegen/src/ty_convert.rs b/codegen/src/ty_convert.rs
new file mode 100644
index 0000000000..ffb293af6f
--- /dev/null
+++ b/codegen/src/ty_convert.rs
@@ -0,0 +1,186 @@
+use rustc_ast::Mutability;
+use rustc_hir::def_id::DefId;
+use rustc_middle::ty::{
+ self, AliasTy, GenericArg, GenericArgKind, GenericParamDef, GenericParamDefKind, Ty, TyCtxt,
+ TyKind,
+};
+
+use crate::BmsTypes;
+pub fn wrap_non_primtiives<'tcx>(
+ ty: Ty<'tcx>,
+ tcx: TyCtxt<'tcx>,
+ wrapper_ids: &BmsTypes,
+) -> Ty<'tcx> {
+ wrap_type_signature(tcx, ty, wrapper_ids)
+}
+
+pub fn wrap_type_signature<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ ty: Ty<'tcx>,
+ bms_types: &BmsTypes,
+) -> Ty<'tcx> {
+ fn go<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, bms_types: &BmsTypes) -> Ty<'tcx> {
+ match ty.kind() {
+ // ----- ADTs -----
+ TyKind::Adt(adt_def, args) => {
+ // if w.primitive_adts.contains(&adt_def.did()) {
+ // return ty;
+ // }
+ if ty.type_in_bms_wrapper(bms_types).is_some() {
+ return ty;
+ }
+
+ // generics preserved
+ if !args.is_empty() {
+ let new_args =
+ tcx.mk_args_from_iter(args.iter().map(|a| go_generic(tcx, a, bms_types)));
+ return tcx.mk_ty_from_kind(TyKind::Adt(*adt_def, new_args));
+ }
+
+ // Non-generic ADT → wrap in Val
+ let new_args =
+ tcx.mk_args_from_iter(args.iter().map(|a| go_generic(tcx, a, bms_types)));
+ let inner = tcx.mk_ty_from_kind(TyKind::Adt(*adt_def, new_args));
+
+ wrap_val(tcx, inner, bms_types)
+ }
+
+ // ----- Alias types -----
+ TyKind::Alias(kind, alias_ty) => {
+ let new_args = tcx
+ .mk_args_from_iter(alias_ty.args.iter().map(|a| go_generic(tcx, a, bms_types)));
+ let new_alias = AliasTy::new_from_args(tcx, alias_ty.def_id, new_args);
+
+ // Do NOT wrap an alias — keep structure.
+ tcx.mk_ty_from_kind(TyKind::Alias(*kind, new_alias))
+ }
+
+ // ----- References (&T, &mut T) -----
+ TyKind::Ref(_region, inner, mutbl) => {
+ let inner_wrapped = go(tcx, *inner, bms_types);
+
+ match mutbl {
+ Mutability::Not => {
+ if matches!(inner_wrapped.kind(),
+ TyKind::Adt(adt, _) if adt.did() == bms_types.ref_wrapper
+ ) {
+ inner_wrapped
+ } else {
+ wrap_ref(tcx, inner_wrapped, bms_types)
+ }
+ }
+ Mutability::Mut => {
+ if matches!(inner_wrapped.kind(),
+ TyKind::Adt(adt, _) if adt.did() == bms_types.mut_wrapper
+ ) {
+ inner_wrapped
+ } else {
+ wrap_mut(tcx, inner_wrapped, bms_types)
+ }
+ }
+ }
+ }
+
+ // ----- Arrays / slices -----
+ TyKind::Array(elem, len) => {
+ let new_elem = go(tcx, *elem, bms_types);
+ tcx.mk_ty_from_kind(TyKind::Array(new_elem, *len))
+ }
+
+ TyKind::Slice(elem) => {
+ let new_elem = go(tcx, *elem, bms_types);
+ tcx.mk_ty_from_kind(TyKind::Slice(new_elem))
+ }
+
+ // ----- Everything else left unchanged -----
+ _ => ty,
+ }
+ }
+
+ fn go_generic<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ arg: GenericArg<'tcx>,
+ bms_types: &BmsTypes,
+ ) -> GenericArg<'tcx> {
+ match arg.kind() {
+ GenericArgKind::Type(t) => go(tcx, t, bms_types).into(),
+ _ => arg,
+ }
+ }
+
+ /// Build GenericArgs for a wrapper ADT so the arg kinds match the wrapper's generics.
+ /// The `inner` type will be placed into the first Type generic parameter encountered.
+ /// Lifetime parameters will receive an erased region.
+ fn make_wrapper_args<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ wrapper_def_id: DefId,
+ inner: Ty<'tcx>,
+ ) -> ty::GenericArgsRef<'tcx> {
+ let generics = tcx.generics_of(wrapper_def_id);
+
+ // iterator producing GenericArg<'tcx>
+ let args_iter = generics.own_params.iter().map(|param: &GenericParamDef| {
+ match param.kind {
+ GenericParamDefKind::Lifetime => {
+ // produce erased region GenericArg
+
+ let erased_region = tcx.lifetimes.re_erased; // adjust if your API differs
+ GenericArg::from(erased_region)
+ }
+
+ GenericParamDefKind::Type { .. } => GenericArg::from(inner),
+
+ GenericParamDefKind::Const { .. } => {
+ // Most wrapper ADTs won't have const params; if they do, you must create a const GenericArg.
+ // For now, abort so the mismatch is explicit.
+ panic!(
+ "wrapper ADT has const generic param; not supported by make_wrapper_args"
+ );
+ }
+ }
+ });
+
+ tcx.mk_args_from_iter(args_iter)
+ }
+
+ fn wrap_val<'tcx>(tcx: TyCtxt<'tcx>, inner: Ty<'tcx>, bms_types: &BmsTypes) -> Ty<'tcx> {
+ // guard double-wrap
+ if inner.type_in_bms_wrapper(bms_types).is_some() {
+ return inner;
+ }
+
+ let adt = tcx.adt_def(bms_types.val_wrapper);
+ let args = make_wrapper_args(tcx, adt.did(), inner);
+ tcx.mk_ty_from_kind(TyKind::Adt(adt, args))
+ }
+
+ fn wrap_ref<'tcx>(tcx: TyCtxt<'tcx>, inner: Ty<'tcx>, bms_types: &BmsTypes) -> Ty<'tcx> {
+ let adt = tcx.adt_def(bms_types.ref_wrapper);
+ let args = make_wrapper_args(tcx, adt.did(), inner);
+ tcx.mk_ty_from_kind(TyKind::Adt(adt, args))
+ }
+
+ fn wrap_mut<'tcx>(tcx: TyCtxt<'tcx>, inner: Ty<'tcx>, bms_types: &BmsTypes) -> Ty<'tcx> {
+ let adt = tcx.adt_def(bms_types.mut_wrapper);
+ let args = make_wrapper_args(tcx, adt.did(), inner);
+ tcx.mk_ty_from_kind(TyKind::Adt(adt, args))
+ }
+
+ go(tcx, ty, bms_types)
+}
+
+pub(crate) trait UnwrapWrapper<'tcx> {
+ fn type_in_bms_wrapper(&self, ctxt: &BmsTypes) -> Option>;
+}
+
+impl<'tcx> UnwrapWrapper<'tcx> for Ty<'tcx> {
+ fn type_in_bms_wrapper(&self, ctxt: &BmsTypes) -> Option> {
+ if let TyKind::Adt(ty, args) = self.kind()
+ && [ctxt.mut_wrapper, ctxt.ref_wrapper, ctxt.val_wrapper].contains(&ty.did())
+ && let Some(inner) = args.iter().find_map(|a| a.as_type())
+ {
+ return Some(inner);
+ }
+ None
+ }
+}
diff --git a/codegen/templates/footer.tera b/codegen/templates/footer.tera
index a9d37435e7..65d27c141f 100644
--- a/codegen/templates/footer.tera
+++ b/codegen/templates/footer.tera
@@ -1,13 +1,7 @@
-{% if args.self_is_bms_lua %}
-{% set bms_lua_path="crate" %}
-{% else %}
-{% set bms_lua_path="bevy_mod_scripting::lua"%}
-{% endif %}
-
-
pub struct {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_camel")}};
{% for item in items %}
+// {{ item.import_path }}
#[script_bindings(
remote,
name = "{{ item.ident | convert_case(case="snake") }}_functions",
@@ -16,7 +10,6 @@ pub struct {{ "ScriptingPlugin" | prefix_cratename | convert_case(case="upper_ca
)]
impl {{item.import_path}} {
{% for function in item.functions %}
-
{% for docstring in function.docstrings %}
/// {{ docstring }}
{% endfor %}
@@ -28,7 +21,7 @@ impl {{item.import_path}} {
: {{ arg.proxy_ty -}},
{%- endfor -%}
) -> {{ function.output.proxy_ty }} {
- let output: {{ function.output.proxy_ty }} =
+ let output: {{ function.output.ty }} =
{%- if function.from_trait_path -%}
{{- function_call_expression(type=item.import_path, trait=function.from_trait_path, function=function.ident) -}}
{%- else -%}
@@ -36,17 +29,10 @@ impl {{item.import_path}} {
{%- endif -%}
(
{%- for arg in function.args -%}
- {%- if arg.proxy_ty is matching("Ref.*")-%}
- &{% endif -%}
- {%- if arg.proxy_ty is matching ("Mut.*")-%}
- &mut {% endif -%}
- {{- arg.ident | to_arg_pattern() -}}
- {%- if arg.proxy_ty is matching("Val.*")-%}
- .into_inner()
- {%- endif -%},
+ safe_transmute({{arg.ident | to_arg_pattern() }}),
{%- endfor -%}
- ).into();
- output
+ );
+ safe_transmute(output)
}
{% endfor %}
}
diff --git a/codegen/templates/header.tera b/codegen/templates/header.tera
index e5fbb05c0a..ba0e6a6fbd 100644
--- a/codegen/templates/header.tera
+++ b/codegen/templates/header.tera
@@ -4,7 +4,7 @@
use bevy_mod_scripting_bindings::{
ReflectReference,
- function::{from::{Ref, Mut, Val}, namespace::{NamespaceBuilder}}
+ function::{from::{Ref, Mut, Val}, namespace::{NamespaceBuilder}, glue::safe_transmute}
};
use bevy_ecs::{prelude::*};
use bevy_app::{App, Plugin};
diff --git a/crates/bevy_mod_scripting_bindings/Cargo.toml b/crates/bevy_mod_scripting_bindings/Cargo.toml
index 59d7901bf9..7bdfb0eb6b 100644
--- a/crates/bevy_mod_scripting_bindings/Cargo.toml
+++ b/crates/bevy_mod_scripting_bindings/Cargo.toml
@@ -32,6 +32,7 @@ profiling = { workspace = true }
bevy_asset = { workspace = true }
variadics_please = { workspace = true }
serde = { workspace = true }
+nonmax = { workspace = true }
[dev-dependencies]
pretty_assertions = { workspace = true }
diff --git a/crates/bevy_mod_scripting_bindings/src/function/from.rs b/crates/bevy_mod_scripting_bindings/src/function/from.rs
index b03b493c4d..7d2465cf98 100644
--- a/crates/bevy_mod_scripting_bindings/src/function/from.rs
+++ b/crates/bevy_mod_scripting_bindings/src/function/from.rs
@@ -5,6 +5,7 @@ use crate::{
};
use bevy_platform::collections::{HashMap, HashSet};
use bevy_reflect::{FromReflect, Reflect};
+use nonmax::NonMaxU32;
use std::{
any::TypeId,
ffi::OsString,
@@ -115,6 +116,28 @@ macro_rules! impl_from_stringlike {
impl_from_stringlike!(String, PathBuf, OsString);
+impl FromScript for NonMaxU32 {
+ type This<'w> = Self;
+
+ fn from_script(
+ value: ScriptValue,
+ _world: WorldGuard<'_>,
+ ) -> Result, InteropError>
+ where
+ Self: Sized,
+ {
+ match value {
+ ScriptValue::Integer(i) if i != 0 => Ok(unsafe { NonMaxU32::new_unchecked(i as u32) }),
+ ScriptValue::Float(f) if f != 0.0 => Ok(unsafe { NonMaxU32::new_unchecked(f as u32) }),
+ // ScriptValue::Reference(r) => r.downcast::(world),
+ _ => Err(InteropError::value_mismatch(
+ std::any::TypeId::of::(),
+ value,
+ )),
+ }
+ }
+}
+
#[profiling::all_functions]
impl FromScript for char {
type This<'w> = Self;
@@ -160,6 +183,7 @@ impl FromScript for ReflectReference {
/// This can be used to retrieve a value out of a [`ScriptValue::Reference`] corresponding to the type `T`.
/// You can also use this to return values from a script function to be allocated directly as a [`ScriptValue::Reference`].
#[derive(Reflect)]
+#[repr(transparent)]
pub struct Val(pub T);
#[profiling::all_functions]
@@ -230,6 +254,7 @@ impl FromScript for Val {
///
/// However, the access is NOT released when the `Mut` is dropped. This is not unsafe but can lead to deadlocks if not released later.
/// The script function calling mechanism will take care of releasing all accesses claimed during the function call.
+#[repr(transparent)]
pub struct Ref<'w, T>(pub &'w T);
impl Deref for Ref<'_, T> {
@@ -291,6 +316,7 @@ impl<'a, T> From<&'a T> for Ref<'a, T> {
///
/// However, the access is NOT released when the `Mut` is dropped. This is not unsafe but can lead to deadlocks if not released later.
/// The [`ScriptFunction`] calling mechanism will take care of releasing all accesses claimed during the function call.
+#[repr(transparent)]
pub struct Mut<'w, T>(pub &'w mut T);
impl Deref for Mut<'_, T> {
diff --git a/crates/bevy_mod_scripting_bindings/src/function/glue.rs b/crates/bevy_mod_scripting_bindings/src/function/glue.rs
new file mode 100644
index 0000000000..8652232855
--- /dev/null
+++ b/crates/bevy_mod_scripting_bindings/src/function/glue.rs
@@ -0,0 +1,334 @@
+//! Glue traits for "unwrapping" bindings to their raw form
+
+use std::{mem, ptr};
+
+use variadics_please::all_tuples;
+
+use crate::{Mut, Ref, Val};
+
+// glue.rs (or wherever)
+mod sealed {
+ // Sealed relationship for a *pair* (L -> R).
+ // This prevents external crates from implementing CanTransmute for arbitrary pairs.
+ pub trait Sealed {}
+}
+
+// Public trait: L can transmute to R
+pub trait CanTransmute: sealed::Sealed {
+ fn safe_transmute(self) -> Rhs;
+}
+
+// === Implementations ===
+
+// =======================
+// Primitive / wrapper identity impls
+// =======================
+
+// For string slices — generic over any lifetime
+impl<'a> sealed::Sealed<&'a str> for &'a str {}
+impl<'a> CanTransmute<&'a str> for &'a str {
+ fn safe_transmute(self) -> &'a str {
+ self
+ }
+}
+
+// Identity for primitives / base types
+macro_rules! impl_identity {
+ ($($t:ty),*) => {
+ $(
+ impl sealed::Sealed<$t> for $t {}
+ impl CanTransmute<$t> for $t {
+ fn safe_transmute(self) -> $t { self }
+ }
+ )*
+ };
+}
+
+// Add the types you need
+impl_identity!(
+ (),
+ usize,
+ isize,
+ u8,
+ u16,
+ u32,
+ u64,
+ u128,
+ i8,
+ i16,
+ i32,
+ i64,
+ i128,
+ bool,
+ char,
+ f32,
+ f64,
+ String
+);
+
+// === Wrapper -> Inner ===
+
+// Ref<'a, T> -> &'b T
+impl<'a, 'b, T> sealed::Sealed<&'b T> for Ref<'a, T> where 'a: 'b {}
+impl<'a, 'b, T> CanTransmute<&'b T> for Ref<'a, T>
+where
+ 'a: 'b,
+{
+ fn safe_transmute(self) -> &'b T {
+ let Ref(inner) = self;
+ inner
+ }
+}
+
+// Mut<'a, T> -> &'b mut T
+impl<'a, 'b, T> sealed::Sealed<&'b mut T> for Mut<'a, T> where 'a: 'b {}
+impl<'a, 'b, T> CanTransmute<&'b mut T> for Mut<'a, T>
+where
+ 'a: 'b,
+{
+ fn safe_transmute(self) -> &'b mut T {
+ let Mut(inner) = self;
+ inner
+ }
+}
+
+// Val -> T
+impl sealed::Sealed for Val {}
+impl CanTransmute for Val {
+ fn safe_transmute(self) -> T {
+ unsafe {
+ let out = std::ptr::read(&self as *const Val as *const T);
+ std::mem::forget(self);
+ out
+ }
+ }
+}
+
+// =======================
+// Recursive container impls
+// =======================
+
+// Vec
+impl sealed::Sealed> for Vec where T: CanTransmute {}
+impl CanTransmute> for Vec
+where
+ T: CanTransmute,
+{
+ fn safe_transmute(self) -> Vec {
+ unsafe { std::mem::transmute(self) }
+ }
+}
+
+impl sealed::Sealed> for Option where T: CanTransmute {}
+
+// Option
+impl CanTransmute> for Option
+where
+ T: CanTransmute,
+{
+ fn safe_transmute(self) -> Option {
+ unsafe {
+ // Bitwise move the whole Option into Option
+ let out = ptr::read(&self as *const Option as *const Option);
+ mem::forget(self);
+ out
+ }
+ }
+}
+
+// Result
+impl sealed::Sealed> for Result
+where
+ T: CanTransmute,
+ E: CanTransmute,
+{
+}
+impl CanTransmute> for Result
+where
+ T: CanTransmute,
+ E: CanTransmute,
+{
+ fn safe_transmute(self) -> Result {
+ unsafe {
+ let out = ptr::read(&self as *const Result as *const Result);
+ mem::forget(self);
+ out
+ }
+ }
+}
+impl sealed::Sealed<[U; N]> for [T; N] where T: CanTransmute {}
+
+impl CanTransmute<[U; N]> for [T; N]
+where
+ T: CanTransmute,
+{
+ fn safe_transmute(self) -> [U; N] {
+ use core::{mem, ptr};
+
+ // Move `self` into a raw pointer
+ let ptr = &self as *const [T; N] as *const [U; N];
+
+ // Prevent drop of `self`
+ let out = unsafe { ptr::read(ptr) };
+
+ mem::forget(self);
+
+ out
+ }
+}
+
+pub fn safe_transmute(input: In) -> Out
+where
+ In: CanTransmute + Sized,
+ Out: Sized,
+{
+ input.safe_transmute()
+}
+
+impl sealed::Sealed> for T {}
+impl CanTransmute> for T {
+ fn safe_transmute(self) -> Val {
+ Val(self)
+ }
+}
+
+impl<'a, T> sealed::Sealed> for &'a T {}
+impl<'a, T> CanTransmute> for &'a T {
+ fn safe_transmute(self) -> Ref<'a, T> {
+ Ref(self)
+ }
+}
+
+impl<'a, T> sealed::Sealed> for &'a mut T {}
+impl<'a, T> CanTransmute> for &'a mut T {
+ fn safe_transmute(self) -> Mut<'a, T> {
+ Mut(self)
+ }
+}
+
+macro_rules! impl_can_transmute_tuple {
+ // Each entry gives us three identifiers: T, U, t
+ ($(($T:ident, $U:ident, $t:ident)),*) => {
+ impl< $( $T: CanTransmute<$U>, $U ),* >
+ sealed::Sealed<( $( $U ),* )>
+ for ( $( $T ),* )
+ {}
+
+ impl< $( $T: CanTransmute<$U>, $U ),* >
+ CanTransmute<( $( $U ),* )>
+ for ( $( $T ),* )
+ {
+ fn safe_transmute(self) -> ( $( $U ),* ) {
+ let ( $( $t ),* ) = self;
+ ( $( $t.safe_transmute() ),* )
+ }
+ }
+ }
+}
+
+all_tuples!(impl_can_transmute_tuple, 2, 15, T, U, t);
+
+#[doc(hidden)]
+pub const fn assert_layout_equiv() {
+ // SAFETY: W must be #[repr(transparent)] over T
+ if std::mem::size_of::() != std::mem::size_of::() {
+ panic!("Invariant broken, size of types is differnt.",)
+ }
+ if std::mem::align_of::() != std::mem::align_of::() {
+ panic!("Invariant broken, alignment of types is differnt.",)
+ }
+}
+
+#[doc(hidden)]
+#[allow(dead_code)]
+const SAFETY_ASSERTION: () = {
+ assert_layout_equiv::, &mut usize>();
+ assert_layout_equiv::, &usize>();
+ assert_layout_equiv::, usize>();
+};
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ #[test]
+ fn test_identity_transmute() {
+ let x: u32 = safe_transmute::(123);
+ assert_eq!(x, 123);
+ }
+
+ #[test]
+ fn test_val_to_inner() {
+ let v = Val(vec![1, 2, 3]);
+ let out: Vec = safe_transmute(v);
+ assert_eq!(out, vec![1, 2, 3]);
+ }
+
+ #[test]
+ fn test_ref_to_ref() {
+ let x = 10;
+ let r = Ref(&x);
+
+ let out: &i32 = safe_transmute(r);
+ assert_eq!(*out, 10);
+ }
+
+ #[test]
+ fn test_mut_to_mut() {
+ let mut x = 5;
+ let m = Mut(&mut x);
+
+ let out: &mut i32 = safe_transmute(m);
+ *out = 99;
+ assert_eq!(x, 99);
+ }
+
+ #[test]
+ fn test_vec_of_val() {
+ let v = vec![Val(1), Val(2), Val(3)];
+ let out: Vec = safe_transmute(v);
+ assert_eq!(out, vec![1, 2, 3]);
+ }
+
+ #[test]
+ fn test_option_of_val_some() {
+ let v = Some(Val(42));
+ let out: Option = safe_transmute(v);
+ assert_eq!(out, Some(42));
+ }
+
+ #[test]
+ fn test_option_of_val_none() {
+ let v: Option