dotnetdll 0.1.3

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

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

pub mod read;
pub mod write;

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) -> Result<Self>;

    fn as_sig(&self, ctx: &mut write::Context) -> Result<Type>;
    fn as_idx(&self, ctx: &mut write::Context) -> Result<TypeDefOrRef>;
    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) -> Result<Self> {
        Ok(match t {
            Type::Var(idx) => MemberType::TypeGeneric(idx as usize),
            rest => MemberType::Base(Box::new(read::base_type_sig(rest, ctx)?)),
        })
    }

    fn as_sig(&self, ctx: &mut write::Context) -> Result<Type> {
        match self {
            MemberType::Base(b) => write::base_sig(&**b, ctx),
            MemberType::TypeGeneric(i) => Ok(Type::Var(*i as u32)),
        }
    }

    fn as_idx(&self, ctx: &mut write::Context) -> Result<TypeDefOrRef> {
        match self {
            MemberType::Base(b) => write::base_index(&**b, ctx),
            MemberType::TypeGeneric(i) => write::into_index(Type::Var(*i as u32), ctx),
        }
    }

    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) -> Result<Self> {
        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)?)),
        })
    }

    fn as_sig(&self, ctx: &mut write::Context) -> Result<Type> {
        match self {
            MethodType::Base(b) => write::base_sig(&**b, ctx),
            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) -> Result<TypeDefOrRef> {
        match self {
            MethodType::Base(b) => write::base_index(&**b, ctx),
            MethodType::TypeGeneric(i) => write::into_index(Type::Var(*i as u32), ctx),
            MethodType::MethodGeneric(i) => write::into_index(Type::MVar(*i as u32), ctx),
        }
    }

    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,
        }
    }
}