interoptopus_csharp 0.16.0-alpha.15

The C# backend for Interoptopus.
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

pub mod all;
pub mod ctor;
pub mod destructor;
pub mod method;

use crate::lang::TypeId;
use crate::lang::types::kind::TypeKind;
use crate::pass::{model, output};

/// Returns the managed service class name if `type_id` is a pointer-to-service.
pub(super) fn resolve_ptr_to_service_name(type_id: TypeId, types: &model::common::types::all::Pass) -> Option<String> {
    let ty = types.get(type_id)?;
    if let TypeKind::Pointer(p) = &ty.kind {
        let target = types.get(p.target)?;
        if matches!(&target.kind, TypeKind::Service) {
            return Some(target.name.clone());
        }
    }
    None
}

/// Returns the managed service class name if `type_id` is a double-pointer to service
/// (i.e., `*const *const Service` — the FFI form of `&Service`).
fn resolve_double_ptr_to_service_name(type_id: TypeId, types: &model::common::types::all::Pass) -> Option<String> {
    let ty = types.get(type_id)?;
    if let TypeKind::Pointer(outer) = &ty.kind {
        let inner = types.get(outer.target)?;
        if let TypeKind::Pointer(p) = &inner.kind {
            let target = types.get(p.target)?;
            if matches!(&target.kind, TypeKind::Service) {
                return Some(target.name.clone());
            }
        }
    }
    None
}

/// Like `unmanaged_args` but handles pointer-to-service params by unwrapping `GCHandle`,
/// and double-pointer-to-service params (ref params) by dereferencing first.
///
/// - Owned service params (`ServiceHandle<T>`, single pointer): uses `T.Unmanaged` arg
///   type and `.IntoManaged()` (frees `GCHandle`, ownership transfer).
/// - Ref service params (`*const ServiceHandle<T>`, double pointer): uses `IntPtr` arg
///   type and `T.Unmanaged { _handle = x }.AsManaged()` (no free, borrow).
pub(super) fn service_aware_args(
    func: &crate::lang::functions::Function,
    types: &model::common::types::all::Pass,
    unmanaged_names: &output::common::conversion::unmanaged_names::Pass,
    unmanaged_conversion: &output::common::conversion::unmanaged_conversion::Pass,
) -> (String, String) {
    let args: Vec<String> = func
        .signature
        .arguments
        .iter()
        .filter_map(|arg| {
            let ty_name = unmanaged_names.name(arg.ty)?;
            Some(format!("{ty_name} {}", arg.name))
        })
        .collect();

    let forward: Vec<String> = func
        .signature
        .arguments
        .iter()
        .map(|a| {
            if let Some(svc_name) = resolve_ptr_to_service_name(a.ty, types) {
                // Owned service param — construct Unmanaged wrapper and IntoManaged (frees GCHandle).
                format!("new {svc_name}.Unmanaged {{ _handle = {} }}.IntoManaged()", a.name)
            } else if let Some(svc_name) = resolve_double_ptr_to_service_name(a.ty, types) {
                // Ref service param — dereference the pointer-to-handle, then AsManaged (no free).
                format!("new {svc_name}.Unmanaged {{ _handle = Marshal.ReadIntPtr({}) }}.AsManaged()", a.name)
            } else {
                format!("{}{}", a.name, unmanaged_conversion.to_managed_suffix(a.ty))
            }
        })
        .collect();

    (args.join(", "), forward.join(", "))
}

/// Like `service_aware_args` but excludes the last argument from `forward_str`
/// (the async callback).
pub(super) fn service_aware_args_except_last(
    func: &crate::lang::functions::Function,
    types: &model::common::types::all::Pass,
    unmanaged_names: &output::common::conversion::unmanaged_names::Pass,
    unmanaged_conversion: &output::common::conversion::unmanaged_conversion::Pass,
) -> (String, String) {
    let n = func.signature.arguments.len().saturating_sub(1);

    let args: Vec<String> = func
        .signature
        .arguments
        .iter()
        .filter_map(|arg| {
            let ty_name = unmanaged_names.name(arg.ty)?;
            Some(format!("{ty_name} {}", arg.name))
        })
        .collect();

    let forward: Vec<String> = func
        .signature
        .arguments
        .iter()
        .take(n)
        .map(|a| {
            if let Some(svc_name) = resolve_ptr_to_service_name(a.ty, types) {
                format!("new {svc_name}.Unmanaged {{ _handle = {} }}.IntoManaged()", a.name)
            } else if let Some(svc_name) = resolve_double_ptr_to_service_name(a.ty, types) {
                format!("new {svc_name}.Unmanaged {{ _handle = Marshal.ReadIntPtr({}) }}.AsManaged()", a.name)
            } else {
                format!("{}{}", a.name, unmanaged_conversion.to_managed_suffix(a.ty))
            }
        })
        .collect();

    (args.join(", "), forward.join(", "))
}