deflect 0.1.0

Reflection in Rust via DWARF debug info.
Documentation 
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
109
110
111
112

use std::{fmt, marker::PhantomData};

use addr2line::gimli::UnitOffset;

/// The kind of a unique pointer.
#[derive(Clone, Copy)]
pub enum Unique {}

/// The kind of a shared pointer.
#[derive(Clone, Copy)]
pub enum Shared {}

/// The kind of a raw `mut` pointer.
#[derive(Clone, Copy)]
pub enum Mut {}

/// The kind of a raw `const` pointer.
#[derive(Clone, Copy)]
pub enum Const {}

mod reference_seal {
    pub trait Sealed {}
    impl Sealed for super::Unique {}
    impl Sealed for super::Shared {}
}

/// A trait implemented by reference kinds.
pub trait Reference: reference_seal::Sealed {}
impl Reference for Unique {}
impl Reference for Shared {}

/// A schema for a shared reference (i.e., `&T`).
#[derive(Clone)]
pub struct Pointer<'dwarf, K, R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    dwarf: &'dwarf crate::gimli::Dwarf<R>,
    unit: &'dwarf crate::gimli::Unit<R, usize>,
    entry: UnitOffset,
    name: Option<super::Name<R>>,
    target: UnitOffset,
    kind: PhantomData<K>,
}

impl<'dwarf, K, R> Pointer<'dwarf, K, R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    /// Construct a new `Shared`.
    pub(super) fn new(
        dwarf: &'dwarf crate::gimli::Dwarf<R>,
        unit: &'dwarf crate::gimli::Unit<R, usize>,
        entry: UnitOffset,
        name: Option<super::Name<R>>,
        target: UnitOffset,
    ) -> Self {
        Self {
            dwarf,
            unit,
            entry,
            name,
            target,
            kind: PhantomData,
        }
    }

    /// The name of this reference type.
    pub fn name(&self) -> Option<&super::Name<R>> {
        self.name.as_ref()
    }

    /// The size of this type, in bytes.
    pub fn size(&self) -> u64 {
        core::mem::size_of::<usize>() as _
    }

    /// The type of the referent.
    pub fn r#type(&self) -> Result<super::Type<'dwarf, R>, crate::Error> {
        let entry = self.unit.entry(self.target)?;
        super::Type::from_die(self.dwarf, self.unit, entry)
    }
}

impl<'dwarf, K, R> fmt::Debug for Pointer<'dwarf, K, R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let entry = self.unit.entry(self.entry).map_err(crate::fmt_err)?;
        let mut debug_tuple = f.debug_tuple("deflect::schema::Shared");
        debug_tuple.field(&crate::debug::DebugEntry::new(
            self.dwarf, self.unit, &entry,
        ));
        debug_tuple.finish()
    }
}

impl<'dwarf, K, R> fmt::Display for Pointer<'dwarf, K, R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if let Some(name) = self.name() {
            name.fmt(f)
        } else {
            f.write_str("*? ")?;
            let target = self.r#type().map_err(crate::fmt_err)?;
            target.fmt(f)
        }
    }
}