dotnetdll 0.3.0

A framework for reading and writing .NET metadata files, such as C# library DLLs.
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::{
    binary::{metadata::index::TypeDefOrRef, signature::encoded::Type},
    dll::{DLLError, ResolveError},
    resolved::types::{BaseType, MemberType, MethodType},
};

pub mod read;
pub mod write;

#[inline]
fn as_resolve(err: &DLLError, context: &'static str) -> ResolveError {
    match err {
        DLLError::Resolve(resolve) => *resolve,
        _ => ResolveError::LazyLookupFailed(context),
    }
}

pub trait TypeKind: Sized + std::hash::Hash + std::fmt::Debug {
    fn from_base(b: BaseType<Self>) -> Self;
    fn from_sig(t: Type, ctx: &read::Context) -> std::result::Result<Self, ResolveError>;

    fn as_sig(&self, ctx: &mut write::Context) -> std::result::Result<Type, ResolveError>;
    fn as_idx(&self, ctx: &mut write::Context) -> std::result::Result<TypeDefOrRef, ResolveError>;
    fn as_base(&self) -> Option<&BaseType<Self>>;

    fn into_base(self) -> Option<BaseType<Self>>;
}

impl TypeKind for MemberType {
    fn from_base(b: BaseType<Self>) -> Self {
        MemberType::Base(Box::new(b))
    }

    fn from_sig(t: Type, ctx: &read::Context) -> std::result::Result<Self, ResolveError> {
        Ok(match t {
            Type::Var(idx) => MemberType::TypeGeneric(idx as usize),
            rest => MemberType::Base(Box::new(
                read::base_type_sig(rest, ctx).map_err(|err| as_resolve(&err, "member type from signature"))?,
            )),
        })
    }

    fn as_sig(&self, ctx: &mut write::Context) -> std::result::Result<Type, ResolveError> {
        match self {
            MemberType::Base(b) => {
                write::base_sig(&**b, ctx).map_err(|err| as_resolve(&err, "member type to signature"))
            }
            MemberType::TypeGeneric(i) => Ok(Type::Var(*i as u32)),
        }
    }

    fn as_idx(&self, ctx: &mut write::Context) -> std::result::Result<TypeDefOrRef, ResolveError> {
        match self {
            MemberType::Base(b) => {
                write::base_index(&**b, ctx).map_err(|err| as_resolve(&err, "member type to index"))
            }
            MemberType::TypeGeneric(i) => {
                write::into_index(Type::Var(*i as u32), ctx).map_err(|err| as_resolve(&err, "member generic to index"))
            }
        }
    }

    fn as_base(&self) -> Option<&BaseType<Self>> {
        match self {
            MemberType::Base(b) => Some(&**b),
            _ => None,
        }
    }

    fn into_base(self) -> Option<BaseType<Self>> {
        match self {
            MemberType::Base(b) => Some(*b),
            _ => None,
        }
    }
}

impl TypeKind for MethodType {
    fn from_base(b: BaseType<Self>) -> Self {
        MethodType::Base(Box::new(b))
    }

    fn from_sig(t: Type, ctx: &read::Context) -> std::result::Result<Self, ResolveError> {
        Ok(match t {
            Type::Var(idx) => MethodType::TypeGeneric(idx as usize),
            Type::MVar(idx) => MethodType::MethodGeneric(idx as usize),
            rest => MethodType::Base(Box::new(
                read::base_type_sig(rest, ctx).map_err(|err| as_resolve(&err, "method type from signature"))?,
            )),
        })
    }

    fn as_sig(&self, ctx: &mut write::Context) -> std::result::Result<Type, ResolveError> {
        match self {
            MethodType::Base(b) => {
                write::base_sig(&**b, ctx).map_err(|err| as_resolve(&err, "method type to signature"))
            }
            MethodType::TypeGeneric(i) => Ok(Type::Var(*i as u32)),
            MethodType::MethodGeneric(i) => Ok(Type::MVar(*i as u32)),
        }
    }

    fn as_idx(&self, ctx: &mut write::Context) -> std::result::Result<TypeDefOrRef, ResolveError> {
        match self {
            MethodType::Base(b) => {
                write::base_index(&**b, ctx).map_err(|err| as_resolve(&err, "method type to index"))
            }
            MethodType::TypeGeneric(i) => {
                write::into_index(Type::Var(*i as u32), ctx).map_err(|err| as_resolve(&err, "method type generic to index"))
            }
            MethodType::MethodGeneric(i) => {
                write::into_index(Type::MVar(*i as u32), ctx).map_err(|err| as_resolve(&err, "method generic to index"))
            }
        }
    }

    fn as_base(&self) -> Option<&BaseType<Self>> {
        match self {
            MethodType::Base(b) => Some(&**b),
            _ => None,
        }
    }

    fn into_base(self) -> Option<BaseType<Self>> {
        match self {
            MethodType::Base(b) => Some(*b),
            _ => None,
        }
    }
}