dprint 0.9.0

Binary for dprint.
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

use wasmer_runtime_core::export::Exportable;
use wasmer_runtime::{Instance, Func, WasmPtr, Array, Memory};

use dprint_core::types::ErrBox;
use dprint_core::plugins::wasm::PLUGIN_SYSTEM_SCHEMA_VERSION;

pub enum FormatResult {
    NoChange = 0,
    Change = 1,
    Error = 2,
}

impl From<u8> for FormatResult {
    fn from(orig: u8) -> Self {
        match orig {
            0 => FormatResult::NoChange,
            1 => FormatResult::Change,
            2 => FormatResult::Error,
            _ => unreachable!(),
        }
    }
}

pub struct WasmFunctions {
    instance: Instance,
}

impl WasmFunctions {
    pub fn new(instance: Instance) -> Result<Self, ErrBox> {
        let plugin_schema_version_func: Func<(), u32> = instance.exports.get("get_plugin_schema_version")?;
        let plugin_schema_version = plugin_schema_version_func.call().unwrap();

        if plugin_schema_version != PLUGIN_SYSTEM_SCHEMA_VERSION {
            return err!(
                "Invalid schema version: {} -- Expected: {}. This may indicate you should upgrade your dprint CLI or plugin.",
                plugin_schema_version,
                PLUGIN_SYSTEM_SCHEMA_VERSION
            );
        }

        Ok(WasmFunctions { instance })
    }

    #[inline]
    pub fn set_global_config(&self) {
        let set_global_config_func: Func = self.get_export("set_global_config");
        set_global_config_func.call().unwrap()
    }

    #[inline]
    pub fn set_plugin_config(&self) {
        let set_plugin_config_func: Func = self.get_export("set_plugin_config");
        set_plugin_config_func.call().unwrap()
    }

    #[inline]
    pub fn get_plugin_info(&self) -> usize {
        let get_plugin_info_func: Func<(), u32> = self.get_export("get_plugin_info");
        get_plugin_info_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_license_text(&self) -> usize {
        let get_license_text_func: Func<(), u32> = self.get_export("get_license_text");
        get_license_text_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_resolved_config(&self) -> usize {
        let get_resolved_config_func: Func<(), u32> = self.get_export("get_resolved_config");
        get_resolved_config_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_config_diagnostics(&self) -> usize {
        let get_config_diagnostics_func: Func<(), u32> = self.get_export("get_config_diagnostics");
        get_config_diagnostics_func.call().unwrap() as usize
    }

    #[inline]
    pub fn set_override_config(&self) {
        let set_override_config_func: Func = self.get_export("set_override_config");
        set_override_config_func.call().unwrap()
    }

    #[inline]
    pub fn set_file_path(&self) {
        let set_file_path_func: Func = self.get_export("set_file_path");
        set_file_path_func.call().unwrap()
    }

    #[inline]
    pub fn format(&self) -> FormatResult {
        let format_func: Func<(), u8> = self.get_export("format");
        format_func.call().unwrap().into()
    }

    #[inline]
    pub fn get_formatted_text(&self) -> usize {
        let get_formatted_text_func: Func<(), u32> = self.get_export("get_formatted_text");
        get_formatted_text_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_error_text(&self) -> usize {
        let get_error_text_func: Func<(), u32> = self.get_export("get_error_text");
        get_error_text_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_memory(&self) -> &Memory {
        self.instance.context().memory(0)
    }

    #[inline]
    pub fn clear_shared_bytes(&self, capacity: usize) {
        let clear_shared_bytes_func: Func<u32> = self.get_export("clear_shared_bytes");
        clear_shared_bytes_func.call(capacity as u32).unwrap();
    }

    #[inline]
    pub fn get_wasm_memory_buffer_size(&self) -> usize {
        let get_wasm_memory_buffer_size_func: Func<(), u32> = self.get_export("get_wasm_memory_buffer_size");
        get_wasm_memory_buffer_size_func.call().unwrap() as usize
    }

    #[inline]
    pub fn get_wasm_memory_buffer_ptr(&self) -> WasmPtr<u8, Array> {
        let get_wasm_memory_buffer_func: Func<(), WasmPtr<u8, Array>> = self.get_export("get_wasm_memory_buffer");
        get_wasm_memory_buffer_func.call().unwrap()
    }

    #[inline]
    pub fn set_buffer_with_shared_bytes(&self, offset: usize, length: usize) {
        let set_buffer_with_shared_bytes_func: Func<(u32, u32)> = self.get_export("set_buffer_with_shared_bytes");
        set_buffer_with_shared_bytes_func.call(offset as u32, length as u32).unwrap();
    }

    #[inline]
    pub fn add_to_shared_bytes_from_buffer(&self, length: usize) {
        let add_to_shared_bytes_from_buffer_func: Func<u32> = self.get_export("add_to_shared_bytes_from_buffer");
        add_to_shared_bytes_from_buffer_func.call(length as u32).unwrap();
    }

    fn get_export<'a, T: Exportable<'a>>(&'a self, name: &str) -> T {
        self.instance.exports.get(name).expect("Expected to find plugin method.")
    }
}