Run test suite on wa-serde-derive

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "serde",
-    "serde_derive",
     "serde_derive_internals",
     "serde_test",
     "test_suite",

serde_derive/Cargo.toml

@@ -17,8 +17,7 @@ default = []
 deserialize_in_place = []
 
 [lib]
-name = "serde_derive"
+crate-type = ["cdylib"]
-proc-macro = true
 
 [dependencies]
 proc-macro2 = "1.0"
@@ -30,3 +29,8 @@ serde = { version = "1.0", path = "../serde" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[workspace]
+
+[patch.crates-io]
+proc-macro2 = { git = "https://github.com/dtolnay/watt" }

serde_derive/src/lib.rs

@@ -68,12 +68,11 @@ extern crate quote;
 #[macro_use]
 extern crate syn;
 
-extern crate proc_macro;
 extern crate proc_macro2;
 
 mod internals;
 
-use proc_macro::TokenStream;
+use proc_macro2::TokenStream;
 use syn::DeriveInput;
 
 #[macro_use]
@@ -87,23 +86,27 @@ mod pretend;
 mod ser;
 mod try;
 
-#[proc_macro_derive(Serialize, attributes(serde))]
+#[no_mangle]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
+pub extern "C" fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
+    let mut input: DeriveInput = match syn::parse2(input) {
-    ser::expand_derive_serialize(&mut input)
+        Ok(input) => input,
-        .unwrap_or_else(to_compile_errors)
+        Err(err) => return err.to_compile_error(),
-        .into()
+    };
+
+    ser::expand_derive_serialize(&mut input).unwrap_or_else(to_compile_errors)
 }
 
-#[proc_macro_derive(Deserialize, attributes(serde))]
+#[no_mangle]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+pub extern "C" fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
+    let mut input: DeriveInput = match syn::parse2(input) {
-    de::expand_derive_deserialize(&mut input)
+        Ok(input) => input,
-        .unwrap_or_else(to_compile_errors)
+        Err(err) => return err.to_compile_error(),
-        .into()
+    };
+
+    de::expand_derive_deserialize(&mut input).unwrap_or_else(to_compile_errors)
 }
 
-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
+fn to_compile_errors(errors: Vec<syn::Error>) -> TokenStream {
     let compile_errors = errors.iter().map(syn::Error::to_compile_error);
     quote!(#(#compile_errors)*)
 }

test_suite/Cargo.toml

@@ -21,7 +21,9 @@ fnv = "1.0"
 macrotest = "=1.0.9"
 prettyplease = "=0.1.14"
 rustversion = "1.0"
-serde = { path = "../serde", features = ["rc", "derive"] }
+serde = { path = "../serde", features = ["rc"] }
-serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
+wa-serde-derive = { path = "../wa-serde-derive" }
 serde_test = { path = "../serde_test" }
 trybuild = { version = "1.0.49", features = ["diff"] }
+
+[workspace]

test_suite/tests/compiletest.rs

@@ -1,3 +1,5 @@
+#![cfg(any())]
+
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
 #[cfg_attr(miri, ignore)]

test_suite/tests/test_annotations.rs

@@ -11,6 +11,7 @@
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_derive::{Deserialize, Serialize};
 
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;

test_suite/tests/test_borrow.rs

@@ -5,6 +5,7 @@
 )]
 
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
 
 use std::borrow::Cow;

test_suite/tests/test_de.rs

@@ -34,6 +34,7 @@ use std::sync::atomic::{AtomicI64, AtomicU64};
 use fnv::FnvHasher;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Configure, Token};
 
 #[macro_use]

test_suite/tests/test_de_error.rs

@@ -7,6 +7,7 @@
 
 use serde::de::IntoDeserializer;
 use serde::Deserialize;
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens_error, Token};
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::{CStr, CString};

test_suite/tests/test_gen.rs

@@ -2,6 +2,7 @@
 // successfully when there are a variety of generics and non-(de)serializable
 // types involved.
 
+#![cfg(any())]
 #![deny(warnings)]
 #![allow(
     unknown_lints,

test_suite/tests/test_identifier.rs

@@ -2,7 +2,7 @@
 
 #![allow(clippy::derive_partial_eq_without_eq)]
 
-use serde::Deserialize;
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 
 #[test]

test_suite/tests/test_ignored_any.rs

@@ -5,6 +5,7 @@ use serde::de::{
     DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
 };
 use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
+use serde_derive::Deserialize;
 
 #[derive(PartialEq, Debug, Deserialize)]
 enum Target {

test_suite/tests/test_macros.rs

@@ -8,7 +8,7 @@
 
 mod bytes;
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_test::{
     assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, Token,
 };

test_suite/tests/test_remote.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::redundant_field_names)]
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 
 mod remote {
     pub struct Unit;

test_suite/tests/test_self.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::used_underscore_binding)]
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 
 #[test]
 fn test_self() {

test_suite/tests/test_ser.rs

@@ -22,7 +22,7 @@ use std::str;
 use std::sync::atomic::{AtomicI64, AtomicU64};
 
 use fnv::FnvHasher;
-use serde::Serialize;
+use serde_derive::Serialize;
 use serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};
 
 #[macro_use]

test_suite/tests/test_serde_path.rs

@@ -2,7 +2,7 @@
 
 #[test]
 fn test_gen_custom_serde() {
-    #[derive(serde::Serialize, serde::Deserialize)]
+    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
     #[serde(crate = "fake_serde")]
     struct Foo;
 

test_suite/tests/test_value.rs

@@ -3,6 +3,7 @@
 use serde::de::value::{self, MapAccessDeserializer};
 use serde::de::{IntoDeserializer, MapAccess, Visitor};
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 use std::fmt;
 

wa-serde-derive/.gitignore

@@ -0,0 +1 @@
+*.wasm

wa-serde-derive/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "wa-serde-derive"
+version = "0.1.137"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+license = "MIT OR Apache-2.0"
+description = "serde_derive compiled to wasm"
+repository = "https://github.com/dtolnay/watt"
+include = ["src"]
+
+[lib]
+name = "serde_derive"
+proc-macro = true
+
+[dependencies]
+watt = "0.4"
+
+[workspace]

wa-serde-derive/src/lib.rs

@@ -0,0 +1,18 @@
+extern crate proc_macro;
+extern crate watt;
+
+use proc_macro::TokenStream;
+use watt::WasmMacro;
+
+static MACRO: WasmMacro = WasmMacro::new(WASM);
+static WASM: &[u8] = include_bytes!("serde_derive.wasm");
+
+#[proc_macro_derive(Serialize, attributes(serde))]
+pub fn derive_serialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_serialize", input)
+}
+
+#[proc_macro_derive(Deserialize, attributes(serde))]
+pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_deserialize", input)
+}