wasm-bindgen/crates/backend/src/lib.rs

#![recursion_limit = "256"]
#![cfg_attr(feature = "extra-traits", deny(missing_debug_implementations))]

extern crate proc_macro2;
#[macro_use]
extern crate quote;
#[macro_use]
extern crate syn;
extern crate serde_json;

extern crate wasm_bindgen_shared as shared;

pub mod ast;
mod codegen;
Finish fixing fallout in all tests 2018-03-31 09:04:00 -07:00			`#![recursion_limit = "256"]`
Only derive extra traits when the `extra-traits` feature is enabled 2018-05-29 11:24:40 -07:00			`#![cfg_attr(feature = "extra-traits", deny(missing_debug_implementations))]`
Split out the AST and codegen into the wasm-bindgen-backend crate 2018-03-29 09:14:32 -07:00
			`extern crate proc_macro2;`
			`#[macro_use]`
			`extern crate quote;`
			`#[macro_use]`
			`extern crate syn;`
Overhaul how type information gets to the CLI This commit is a complete overhaul of how the `#[wasm_bindgen]` macro communicates type information to the CLI tool, and it's done in a somewhat... unconventional fashion. Today we've got a problem where the generated JS needs to understand the types of each function exported or imported. This understanding is what enables it to generate the appropriate JS wrappers and such. We want to, however, be quite flexible and extensible in types that are supported across the boundary, which means that internally we rely on the trait system to resolve what's what. Communicating the type information historically was done by creating a four byte "descriptor" and using associated type projections to communicate that to the CLI tool. Unfortunately four bytes isn't a lot of space to cram information like arguments to a generic function, tuple types, etc. In general this just wasn't flexible enough and the way custom references were treated was also already a bit of a hack. This commit takes a radical step of creating a descriptor function for each function imported/exported. The really crazy part is that the `wasm-bindgen` CLI tool now embeds a wasm interpreter and executes these functions when the CLI tool is invoked. By allowing arbitrary functions to get executed it's now much easier to inform `wasm-bindgen` about complicated structures of types. Rest assured though that all these descriptor functions are automatically unexported and gc'd away, so this should not have any impact on binary sizes A new internal trait, `WasmDescribe`, is added to represent a description of all types, sort of like a serialization of the structure of a type that `wasm-bindgen` can understand. This works by calling a special exported function with a `u32` value a bunch of times. This means that when we run a descriptor we effectively get a `Vec<u32>` in the `wasm-bindgen` CLI tool. This list of integers can then be parsed into a rich `enum` for the JS generation to work with. This commit currently only retains feature parity with the previous implementation. I hope to soon solve issues like #123, #104, and #111 with this support. 2018-04-13 07:33:46 -07:00			`extern crate serde_json;`
Split out the AST and codegen into the wasm-bindgen-backend crate 2018-03-29 09:14:32 -07:00
			`extern crate wasm_bindgen_shared as shared;`

			`pub mod ast;`
			`mod codegen;`