lol

Author: alexcrichton

Cargo.toml

@@ -18,4 +18,7 @@ include = [
 ]
 
 [workspace]
-members = ["demo/caller", "demo/wa", "runtime/tests"]
+members = ["demo/caller", "demo/wa", "runtime/tests", "proc-macro"]
+
+[patch.crates-io]
+watt = { path = "." }

demo/impl/src/lib.rs

@@ -1,22 +1,21 @@
-use proc_macro2::TokenStream;
+use proc_macro2::*;
 use quote::quote;
 use syn::DeriveInput;
 
 #[no_mangle]
-pub extern "C" fn demo(input: TokenStream) -> TokenStream {
-    proc_macro2::set_wasm_panic_hook();
-
-    let input: DeriveInput = match syn::parse2(input) {
+pub extern "C" fn demo(input: RawTokenStream) -> RawTokenStream {
+    let input: DeriveInput = match syn::parse2(input.into_token_stream()) {
         Ok(input) => input,
-        Err(err) => return err.to_compile_error(),
+        Err(err) => return err.to_compile_error().into_raw_token_stream(),
     };
 
     let ident = input.ident;
     let message = format!("Hello from WASM! My name is {}.", ident);
 
-    quote! {
+    let ret = quote! {
         impl #ident {
             pub const MESSAGE: &'static str = #message;
         }
-    }
+    };
+    ret.into_raw_token_stream()
 }

demo/wa/Cargo.toml

@@ -9,4 +9,4 @@ publish = false
 proc-macro = true
 
 [dependencies]
-watt = { path = "../.." }
+watt = "0.1"

proc-macro/src/decode.rs

@@ -0,0 +1,119 @@
+use super::*;
+use std::str;
+
+pub fn decode(mut buf: &[u8]) -> TokenStream {
+    let ret = TokenStream::decode(&mut buf);
+    assert!(buf.is_empty());
+    return ret;
+}
+
+trait Decode {
+    fn decode(data: &mut &[u8]) -> Self;
+}
+
+fn byte(data: &mut &[u8]) -> u8 {
+    let ret = data[0];
+    *data = &data[1..];
+    ret
+}
+
+fn str<'a>(data: &mut &'a [u8]) -> &'a str {
+    let len = u32::decode(data) as usize;
+    let ret = str::from_utf8(&data[..len]).unwrap();
+    *data = &data[len..];
+    return ret;
+}
+
+impl Decode for TokenStream {
+    fn decode(data: &mut &[u8]) -> Self {
+        let mut tokens = Vec::new();
+        loop {
+            match byte(data) {
+                0 => break,
+                1 => tokens.push(TokenTree::Group(Group::decode(data))),
+                2 => tokens.push(TokenTree::Ident(Ident::decode(data))),
+                3 => tokens.push(TokenTree::Punct(Punct::decode(data))),
+                _ => tokens.push(TokenTree::Literal(Literal::decode(data))),
+            }
+        }
+        TokenStream { inner: tokens }
+    }
+}
+
+impl Decode for Group {
+    fn decode(data: &mut &[u8]) -> Self {
+        let delimiter = Delimiter::decode(data);
+        let span = Span::decode(data);
+        let stream = TokenStream::decode(data);
+        let mut ret = Group::new(delimiter, stream);
+        ret.set_span(span);
+        return ret;
+    }
+}
+
+impl Decode for Delimiter {
+    fn decode(data: &mut &[u8]) -> Self {
+        match byte(data) {
+            0 => Delimiter::Parenthesis,
+            1 => Delimiter::Brace,
+            2 => Delimiter::Bracket,
+            _ => Delimiter::None,
+        }
+    }
+}
+
+impl Decode for Span {
+    fn decode(data: &mut &[u8]) -> Self {
+        Span {
+            handle: u32::decode(data),
+        }
+    }
+}
+
+impl Decode for u32 {
+    fn decode(data: &mut &[u8]) -> Self {
+        let ret = ((data[0] as u32) << 0)
+            | ((data[1] as u32) << 8)
+            | ((data[2] as u32) << 16)
+            | ((data[3] as u32) << 24);
+        *data = &data[4..];
+        return ret;
+    }
+}
+
+impl Decode for Ident {
+    fn decode(data: &mut &[u8]) -> Self {
+        let span = Span::decode(data);
+        let name = str(data);
+        Ident::new(name, span)
+    }
+}
+
+impl Decode for Punct {
+    fn decode(data: &mut &[u8]) -> Self {
+        let mut p = Punct::new(
+            char::from_u32(u32::decode(data)).unwrap(),
+            Spacing::decode(data),
+        );
+        p.set_span(Span::decode(data));
+        return p;
+    }
+}
+
+impl Decode for Spacing {
+    fn decode(data: &mut &[u8]) -> Self {
+        match byte(data) {
+            0 => Spacing::Alone,
+            _ => Spacing::Joint,
+        }
+    }
+}
+
+impl Decode for Literal {
+    fn decode(data: &mut &[u8]) -> Self {
+        Literal {
+            span: Span::decode(data),
+            text: str(data).to_string(),
+        }
+    }
+}

proc-macro/src/encode.rs

@@ -0,0 +1,117 @@
+use super::*;
+use std::convert::TryFrom;
+
+pub fn encode(stream: TokenStream) -> Vec<u8> {
+    let mut dst = Vec::new();
+    stream.encode(&mut dst);
+    dst
+}
+
+trait Encode {
+    fn encode(self, dst: &mut Vec<u8>);
+}
+
+impl Encode for TokenStream {
+    fn encode(self, dst: &mut Vec<u8>) {
+        for token in self {
+            token.encode(dst);
+        }
+        dst.push(0);
+    }
+}
+
+impl Encode for TokenTree {
+    fn encode(self, dst: &mut Vec<u8>) {
+        match self {
+            TokenTree::Group(g) => {
+                dst.push(1);
+                g.encode(dst);
+            }
+            TokenTree::Ident(i) => {
+                dst.push(2);
+                i.encode(dst);
+            }
+            TokenTree::Punct(p) => {
+                dst.push(3);
+                p.encode(dst);
+            }
+            TokenTree::Literal(l) => {
+                dst.push(4);
+                l.encode(dst);
+            }
+        }
+    }
+}
+
+impl Encode for Group {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.delimiter().encode(dst);
+        self.span().encode(dst);
+        self.stream().encode(dst);
+    }
+}
+
+impl Encode for Delimiter {
+    fn encode(self, dst: &mut Vec<u8>) {
+        dst.push(self as u8);
+    }
+}
+
+impl Encode for Span {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.handle.encode(dst);
+    }
+}
+
+impl Encode for u32 {
+    fn encode(self, dst: &mut Vec<u8>) {
+        dst.extend_from_slice(&self.to_le_bytes());
+    }
+}
+
+impl Encode for usize {
+    fn encode(self, dst: &mut Vec<u8>) {
+        u32::try_from(self).unwrap().encode(dst)
+    }
+}
+
+impl Encode for Ident {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.span().encode(dst);
+        self.to_string().encode(dst);
+    }
+}
+
+impl Encode for String {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.len().encode(dst);
+        dst.extend_from_slice(self.as_bytes());
+    }
+}
+
+impl Encode for Punct {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.as_char().encode(dst);
+        self.spacing().encode(dst);
+        self.span().encode(dst);
+    }
+}
+
+impl Encode for char {
+    fn encode(self, dst: &mut Vec<u8>) {
+        (self as u32).encode(dst);
+    }
+}
+
+impl Encode for Spacing {
+    fn encode(self, dst: &mut Vec<u8>) {
+        dst.push(self as u8);
+    }
+}
+
+impl Encode for Literal {
+    fn encode(self, dst: &mut Vec<u8>) {
+        self.span().encode(dst);
+        self.to_string().encode(dst);
+    }
+}