Dans le cadre de la poursuite de mes recherches sur divers aspects des macros procédurales, je souhaite partager une approche pour étendre leurs capacités. Permettez-moi de vous rappeler que les macros procédurales vous permettent d'ajouter un élément de métaprogrammation au langage et ainsi de simplifier considérablement les opérations de routine, telles que la sérialisation ou le traitement des requêtes. À la base, les macros sont des plugins de compilation qui se compilent avant de construire le rack dans lequel elles sont utilisées. Ces macros présentent certains inconvénients importants.
- Difficulté à prendre en charge de telles macros dans l'EDI. En fait, vous devez d'une manière ou d'une autre apprendre à l'analyseur de code à compiler, charger et exécuter ces macros par elles-mêmes, en tenant compte de toutes les fonctionnalités. Il s'agit d'une tâche très simple.
- Comme les macros sont autosuffisantes et ne se connaissent pas, il n'y a aucun moyen de composer des macros, ce qui pourrait parfois être utile.
En ce qui concerne la résolution du premier problème, des expériences sont en cours avec la compilation de toutes les macros procédurales dans les modules WASM, ce qui permettra à l'avenir de refuser complètement de les compiler sur la machine cible, et en même temps de résoudre le problème avec leur support dans l'IDE.
Quant au deuxième problème, dans cet article, je vais juste parler de mon approche pour résoudre ce problème. En fait, nous avons besoin d'une macro qui peut utiliser les attributs pour charger des macros supplémentaires et les combiner dans un pipeline. Dans le cas le plus simple, vous pouvez simplement imaginer quelque chose comme ceci:
Supposons que nous ayons une macro TextMessagequi affiche des traits pour un type donné ToStringet en FromStrutilisant un codec comme représentation textuelle. Différents types de messages peuvent avoir un codec différent, et leur liste complète peut s'étendre au fil du temps, et chaque codec peut avoir son propre ensemble unique d'attributs.
#[derive(Debug, Serialize, Deserialize, PartialEq, TextMessage)]
#[text_message(codec = "serde_json", params(pretty))]
struct FooMessage {
name: String,
description: String,
value: u64,
}
, . libloading, IDE. , syn quote, , .
WASM , . .
, watt WASM , . watt proc-macro2, . , darling proc-macro2, .
, proc-macro2, WASM
- . , wasmtime, bytecodealliance, , Mozilla, Intel RedHat. wasmtime , , ,
Disclaimer: wasmtime ,
, , . WASM , .
!
, , , WASM , . .
:
pub fn implement_codec(input: TokenStream) -> TokenStream;
, , . TokenStream , :
pub fn implement_codec(input: &str) -> String;
, ,
, :
, , ! WASM , , , , .
, , , . , , , , , . : .
#[no_mangle]
pub unsafe extern "C" fn toy_alloc(size: i32) -> i32 {
let size_bytes: [u8; 4] = size.to_le_bytes();
let mut buf: Vec<u8> = Vec::with_capacity(size as usize + size_bytes.len());
buf.extend(size_bytes.iter());
to_host_ptr(buf)
}
unsafe fn to_host_ptr(mut buf: Vec<u8>) -> i32 {
let ptr = buf.as_mut_ptr();
mem::forget(buf);
ptr as *mut c_void as usize as i32
}
#[no_mangle]
pub unsafe extern "C" fn toy_free(ptr: i32) {
let ptr = ptr as usize as *mut u8;
let mut size_bytes = [0u8; 4];
ptr.copy_to(size_bytes.as_mut_ptr(), 4);
let size = u32::from_le_bytes(size_bytes) as usize;
Vec::from_raw_parts(ptr, size, size);
}
, , wasm_bindgen.
WASM . , .
#[no_mangle]
pub unsafe extern "C" fn implement_codec(
item_ptr: i32,
item_len: i32,
) -> i32 {
let item = str_from_raw_parts(item_ptr, item_len);
let item = TokenStream::from_str(&item).expect("Unable to parse item");
let tokens = codec::implement_codec(item);
let out = tokens.to_string();
to_host_buf(out)
}
pub unsafe fn str_from_raw_parts<'a>(ptr: i32, len: i32) -> &'a str {
let slice = std::slice::from_raw_parts(ptr as *const u8, len as usize);
std::str::from_utf8(slice).unwrap()
}
, WASM .
pub struct WasmMacro {
module: Module,
}
impl WasmMacro {
pub fn from_file(file: impl AsRef<Path>) -> anyhow::Result<Self> {
let store = Store::default();
let module = Module::from_file(&store, file)?;
Ok(Self { module })
}
pub fn proc_macro_derive(
&self,
fun: &str,
item: TokenStream,
) -> anyhow::Result<TokenStream> {
let item = item.to_string();
let instance = Instance::new(&self.module, &[])?;
let proc_macro_attribute_fn = instance
.get_export(fun)
.ok_or_else(|| anyhow!("Unable to find `{}` method in the export table", fun))?
.func()
.ok_or_else(|| anyhow!("export {} is not a function", fun))?
.get2::<i32, i32, i32,>()?;
let item_buf = WasmBuf::from_host_buf(&instance, item);
let (item_ptr, item_len) = item_buf.raw_parts();
let ptr = proc_macro_attribute_fn(item_ptr, item_len).unwrap();
let res = WasmBuf::from_raw_ptr(&instance, ptr);
let res_str = std::str::from_utf8(res.as_ref())?;
TokenStream::from_str(&res_str)
.map_err(|_| anyhow!("Unable to parse token stream"))
}
}
WasmBuf : ,
, toy_alloc.
, .
struct WasmBuf<'a> {
offset: usize,
len: usize,
instance: &'a Instance,
memory: &'a Memory,
}
const WASM_PTR_LEN: usize = 4;
impl<'a> WasmBuf<'a> {
pub fn new(instance: &'a Instance, len: usize) -> Self {
let memory = Self::get_memory(instance);
let offset = Self::toy_alloc(instance, len);
Self {
offset: offset as usize,
len,
instance,
memory,
}
}
pub fn from_host_buf(instance: &'a Instance, bytes: impl AsRef<[u8]>) -> Self {
let bytes = bytes.as_ref();
let len = bytes.len();
let mut wasm_buf = Self::new(instance, len);
wasm_buf.as_mut().copy_from_slice(bytes);
wasm_buf
}
pub fn from_raw_ptr(instance: &'a Instance, offset: i32) -> Self {
let offset = offset as usize;
let memory = Self::get_memory(instance);
let len = unsafe {
let buf = memory.data_unchecked();
let mut len_bytes = [0; WASM_PTR_LEN];
len_bytes.copy_from_slice(&buf[offset..offset + WASM_PTR_LEN]);
u32::from_le_bytes(len_bytes)
};
Self {
offset,
len: len as usize,
memory,
instance,
}
}
pub fn as_ref(&self) -> &[u8] {
unsafe {
let begin = self.offset + WASM_PTR_LEN;
let end = begin + self.len;
&self.memory.data_unchecked()[begin..end]
}
}
pub fn as_mut(&mut self) -> &mut [u8] {
unsafe {
let begin = self.offset + WASM_PTR_LEN;
let end = begin + self.len;
&mut self.memory.data_unchecked_mut()[begin..end]
}
}
}
, .
impl Drop for WasmBuf<'_> {
fn drop(&mut self) {
Self::toy_free(self.instance, self.len);
}
}
,
WASM , .
#[proc_macro_derive(TextMessage, attributes(text_message))]
pub fn text_message(input: TokenStream) -> TokenStream {
let input: DeriveInput = parse_macro_input!(input);
let attrs = TextMessageAttrs::from_raw(&input.attrs)
.expect("Unable to parse text message attributes.");
let codec_dir = Path::new(&std::env::var("CARGO_MANIFEST_DIR")
.unwrap())
.join("codecs");
let plugin_name = format!("{}_text_codec.wasm", attrs.codec);
let codec_path = codec_dir.join(plugin_name);
let wasm_macro = WasmMacro::from_file(codec_path)
.expect("Unable to load wasm module");
wasm_macro
.proc_macro_derive(
"implement_codec",
input.into_token_stream().into(),
)
.expect("Unable to apply proc_macro_attribute")
}
. , WASM , .
#[derive(Debug, Serialize, Deserialize, PartialEq, TextMessage)]
#[text_message(codec = "serde_json", params(pretty))]
struct FooMessage {
name: String,
description: String,
value: u64,
}
fn main() {
let msg = FooMessage {
name: "Linus Torvalds".to_owned(),
description: "The Linux founder.".to_owned(),
value: 1,
};
let text = msg.to_string();
println!("{}", text);
let msg2 = text.parse().unwrap();
assert_eq!(msg, msg2);
}
Bien que cela ressemble plus à un chariot à partir d'une miche de pain, mais d'un autre côté, c'est une petite mais merveilleuse démonstration du principe lui-même. Ces macros deviennent ouvertes à l'expansion. Nous n'avons plus besoin de réécrire la macro procédurale d'origine pour modifier ou étendre son comportement. Et si vous utilisez le registre de modules pour WASM, vous pouvez distribuer de tels modules comme des caisses de chargement.