bevy_api_gen 0.6.0

Code generator tool for bevy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

use log::trace;
use rustc_hir::def_id::LOCAL_CRATE;
use rustc_span::Symbol;

use crate::{
    Args, BevyCtxt, DEF_PATHS_FROM_LUA, DEF_PATHS_GET_TYPE_REGISTRATION, DEF_PATHS_INTO_LUA,
    DEF_PATHS_REFLECT, STD_SOURCE_TRAITS,
};

/// 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_FROM_LUA.contains(&def_path_str.as_str()) {
            trace!("found FromLuaMulti trait def id: {trait_did:?}");
            ctxt.cached_traits.mlua_from_lua_multi = Some(trait_did);
        } else if DEF_PATHS_INTO_LUA.contains(&def_path_str.as_str()) {
            trace!("found ToLuaMulti trait def id: {trait_did:?}");
            ctxt.cached_traits.mlua_into_lua_multi = Some(trait_did);
        } else if DEF_PATHS_REFLECT.contains(&def_path_str.as_str()) {
            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_SOURCE_TRAITS.contains(&def_path_str.as_str()) {
            trace!("found misc trait def id: {trait_did:?}");
            ctxt.cached_traits
                .std_source_traits
                .insert(def_path_str.to_string(), trait_did);
        } else if STD_SOURCE_TRAITS.contains(&def_path_str.as_str()) {
            trace!("found misc trait def id: {trait_did:?}");
            ctxt.cached_traits
                .std_source_traits
                .insert(def_path_str.to_string(), trait_did);
        }
    }

    if !ctxt.cached_traits.has_all_mlua_traits() {
        panic!(
            "Could not find all mlua traits in crate: {}, did bootstrapping go wrong?",
            tcx.crate_name(LOCAL_CRATE)
        )
    }

    if !ctxt.cached_traits.has_all_bevy_traits() {
        panic!(
            "Could not find all reflect traits in crate: {}, did bootstrapping go wrong?",
            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::<Vec<_>>()
                .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
}