dotscope 0.7.0

A high-performance, cross-platform framework for analyzing and reverse engineering .NET PE executables
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

//! Test utilities and mock data builders for unit testing
//!
//! This module provides comprehensive mock data builders for testing complex
//! .NET metadata structures. The goal is to create reusable, composable mock
//! builders that can generate realistic test data covering all major types.
//!
//! # Module Organization
//!
//! - **builders/** - Fluent API builders for creating mock metadata objects
//! - **factories/** - Migrated test factory methods organized by domain
//! - **scenarios/** - Pre-built complex scenarios and test data combinations  
//! - **helpers/** - Legacy helper functions and utilities
//! - **windowsbase.rs** - Windows-specific test helpers and verification
//!
//! # Mock Data Architecture
//!
//! ## 1. CORE BUILDERS (completed):
//! - ModuleRefBuilder - For module references
//! - AssemblyRefBuilder - For assembly references with versioning
//! - FileBuilder - For file metadata
//! - MethodBuilder - For methods with signatures and flags
//! - CilTypeBuilder - For types with inheritance and members
//! - ExportedTypeBuilder - For exported type definitions
//!
//! ## 2. ADVANCED BUILDERS (TODO):
//! - MethodBodyBuilder - for IL code, local vars, exception handlers
//! - SignatureBuilder - for complex method/type signatures
//! - CustomAttributeBuilder - for custom attributes with various data types
//! - GenericTypeBuilder - for generic types with constraints
//! - FieldBuilder - for fields with layouts, marshalling
//! - PropertyBuilder - for properties with getters/setters
//! - EventBuilder - for events with add/remove methods
//! - SecurityBuilder - for security attributes and permissions
//! - ResourceBuilder - for embedded resources
//!
//! ## 3. SCENARIO BUILDERS (TODO):
//! - ComplexTypeHierarchyBuilder - inheritance chains, interfaces
//! - GenericScenarioBuilder - generic classes, methods, constraints
//! - PInvokeScenarioBuilder - native interop scenarios
//! - AsyncMethodScenarioBuilder - async/await patterns
//! - ExceptionHandlingScenarioBuilder - try/catch/finally patterns
//! - LINQScenarioBuilder - LINQ expressions and delegates
//!
//! ## 4. INTEGRATION BUILDERS (TODO):
//! - AssemblyBuilder - complete assembly with multiple types/methods
//! - ModuleBuilder - complete module with dependencies
//! - PackageBuilder - multi-assembly scenarios
//!
//! ## 5. VALIDATION TEST DATA (TODO):
//! - MalformedDataBuilder - for validation error testing
//! - EdgeCaseBuilder - boundary conditions, limits
//! - PerformanceDataBuilder - large-scale data for performance tests
//!
//! # Usage Patterns
//!
//! ```rust,no_run
//! use dotscope::test::{builders::*, scenarios::*};
//!
//! // Fluent API usage
//! let assembly = AssemblyRefBuilder::new()
//!     .with_name("TestAssembly")
//!     .with_version(1, 0, 0, 0)
//!     .build();
//!
//! // Preset scenarios
//! let method = MethodBuilder::simple_void_method("TestMethod").build();
//! let class_type = CilTypeBuilder::simple_class("Test", "MyClass").build();
//!
//! // Complex scenarios
//! let (base_class, derived_class) = create_inheritance_scenario();
//! let standard_refs = create_standard_assembly_refs();
//! ```
//!
//! ### Examples (`examples/`)
//! Comprehensive examples showing how to use the builders for realistic scenarios:
//! - Field validation testing
//! - Method signature creation
//! - Custom attribute scenarios
//! - Generic type definitions

pub mod analysis;
pub mod builders;
mod crafted2;
#[cfg(feature = "emulation")]
pub mod emulation;
pub mod factories;
pub mod helpers;
pub mod mono;
mod scenarios;
mod validator;
mod windowsbase;

pub use builders::*;
pub use crafted2::*;
pub use helpers::*;
pub use validator::*;
pub use windowsbase::*;
//pub use scenarios::*;

use crate::{
    analysis::{SsaType, TypeProvider},
    metadata::{signatures::SignatureLocalVariable, token::Token},
    CilObject,
};

/// Test-only type provider that declares explicit types for synthetic CIL.
///
/// Used by converter tests that build SSA from inline CIL without real
/// assembly metadata. The test author explicitly chooses this provider
/// to declare "all args and locals in this test are I32."
pub struct TestTypeProvider {
    num_args: usize,
    num_locals: usize,
}

impl TestTypeProvider {
    /// Creates a new test type provider with the given argument and local counts.
    #[must_use]
    pub fn new(num_args: usize, num_locals: usize) -> Self {
        Self {
            num_args,
            num_locals,
        }
    }
}

impl TypeProvider for TestTypeProvider {
    fn arg_type(&self, idx: u16) -> SsaType {
        if (idx as usize) < self.num_args {
            SsaType::I32
        } else {
            SsaType::Unknown
        }
    }

    fn local_type(&self, idx: u16) -> SsaType {
        if (idx as usize) < self.num_locals {
            SsaType::I32
        } else {
            SsaType::Unknown
        }
    }

    fn call_return_type(&self, _: Token) -> SsaType {
        SsaType::I32
    }

    fn newobj_type(&self, _: Token) -> SsaType {
        SsaType::Object
    }

    fn field_type(&self, _: Token) -> SsaType {
        SsaType::I32
    }

    fn call_indirect_return_type(&self, _: Token) -> SsaType {
        SsaType::I32
    }

    fn assembly(&self) -> Option<&CilObject> {
        None
    }

    fn local_type_signatures(&self) -> Option<Vec<SignatureLocalVariable>> {
        None
    }
}