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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use super::*;

////////////////////////////////////////////////////////////////////////////////

#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(Copy, Clone)]
pub struct _private_TypeLayoutDerive {
    pub shared_vars: &'static SharedVars,
    pub mono: &'static MonoTypeLayout,
    pub abi_consts: AbiConsts,
    pub data: GenericTLData,
    pub tag: Option<&'static Tag>,
    pub extra_checks: Option<&'static ManuallyDrop<StoredExtraChecks>>,
}

#[allow(non_camel_case_types)]
#[doc(hidden)]
#[derive(Copy, Clone)]
pub struct _private_MonoTypeLayoutDerive {
    pub name: RStr<'static>,
    pub item_info: ItemInfo,
    pub data: MonoTLData,
    pub generics: CompGenericParams,
    pub repr_attr: ReprAttr,
    pub mod_refl_mode: ModReflMode,
    pub phantom_fields: RSlice<'static, CompTLFieldRepr>,
    pub shared_vars: MonoSharedVars,
}

/// Information about where a type was declared.
#[repr(C)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, StableAbi)]
#[sabi(unsafe_sabi_opaque_fields)]
pub struct ItemInfo {
    /// The package where the type was defined,and the version string.
    /// With the `package;version_number` format.
    package_and_version: RStr<'static>,
    /// The line in the file where the type was defined.
    pub line: u32,
    /// The full path to the module where the type was defined,
    /// including the package name
    pub mod_path: ModPath,
}

impl ItemInfo {
    #[doc(hidden)]
    pub const fn new(package_and_version: &'static str, line: u32, mod_path: ModPath) -> Self {
        Self {
            package_and_version: RStr::from_str(package_and_version),
            line,
            mod_path,
        }
    }

    /// Constructs an ItemInfo for a std primitive
    pub const fn primitive() -> Self {
        Self {
            package_and_version: RStr::from_str("std;1.0.0"),
            line: 0,
            mod_path: ModPath::PRELUDE,
        }
    }

    /// Constructs an ItemInfo for an std type with a path.
    pub const fn std_type_in(mod_path: NulStr<'static>) -> Self {
        Self {
            package_and_version: RStr::from_str("std;1.0.0"),
            line: 0,
            mod_path: ModPath::inside(mod_path),
        }
    }

    /// Constructs an ItemInfo for a type in a package and the path to its module.
    ///
    /// `package_and_version` must be formatted like this:`package_name;major.minor.patch`
    ///
    /// `mod_path` must include the crate name.
    pub const fn package_and_mod(
        package_and_version: &'static str,
        mod_path: NulStr<'static>,
    ) -> Self {
        Self {
            package_and_version: RStr::from_str(package_and_version),
            line: 0,
            mod_path: ModPath::inside(mod_path),
        }
    }

    /// Gets the package name and an unparsed package version.
    pub fn package_and_version(&self) -> (&'static str, &'static str) {
        let pav = self.package_and_version.as_str();
        match pav.find(';') {
            Some(separator) => (&pav[..separator], &pav[(separator + 1)..]),
            None => (pav, ""),
        }
    }

    /// Gets the package name.
    pub fn package(&self) -> &'static str {
        self.package_and_version().0
    }

    /// Gets the unparsed package version.
    pub fn version(&self) -> &'static str {
        self.package_and_version().1
    }
}