Add support for optional slice types (#507)

* Shard the `convert.rs` module into sub-modules

Hopefully this'll make the organization a little nicer over time!

* Start adding support for optional types

This commit starts adding support for optional types to wasm-bindgen as
arguments/return values to functions. The strategy here is to add two new
traits, `OptionIntoWasmAbi` and `OptionFromWasmAbi`. These two traits are used
as a blanket impl to implement `IntoWasmAbi` and `FromWasmAbi` for `Option<T>`.

Some consequences of this design:

* It should be possible to ensure `Option<SomeForeignType>` implements to/from
  wasm traits. This is because the option-based traits can be implemented for
  foreign types.
* A specialized implementation is possible for all types, so there's no need for
  `Option<T>` to introduce unnecessary overhead.
* Two new traits is a bit unforutnate but I can't currently think of an
  alternative design that works for the above two constraints, although it
  doesn't mean one doesn't exist!
* The error messages for "can't use this type here" is actually halfway decent
  because it says these new traits need to be implemented, which provides a good
  place to document and talk about what's going on here!
* Nested references like `Option<&T>` can't implement `FromWasmAbi`. This means
  that you can't define a function in Rust which takes `Option<&str>`. It may be
  possible to do this one day but it'll likely require more trait trickery than
  I'm capable of right now.

* Add support for optional slices

This commit adds support for optional slice types, things like strings and
arrays. The null representation of these has a pointer value of 0, which should
never happen in normal Rust. Otherwise the various plumbing is done throughout
the tooling to enable these types in all locations.

* Fix `takeObject` on global sentinels

These don't have a reference count as they're always expected to work, so avoid
actually dropping a reference on them.

* Remove some no longer needed bindings

* Add support for optional anyref types

This commit adds support for optional imported class types. Each type imported
with `#[wasm_bindgen]` automatically implements the relevant traits and now
supports `Option<Foo>` in various argument/return positions.

* Fix building without the `std` feature

* Actually fix the build...

* Add support for optional types to WebIDL

Closes #502

crates/web-sys/tests/all/headers.rs

@@ -6,14 +6,31 @@ fn headers() {
         .file(
             "src/lib.rs",
             r#"
-                #![feature(use_extern_macros)]
+                #![feature(use_extern_macros, wasm_import_module)]
                 extern crate wasm_bindgen;
                 use wasm_bindgen::prelude::*;
                 extern crate web_sys;
 
                 #[wasm_bindgen]
-                pub fn test_headers(_headers: &web_sys::Headers) {
-                    // empty for now...
+                pub fn test_headers(headers: &web_sys::Headers) {
+                    assert_eq!(headers.get("foo").unwrap(), None);
+                    assert_eq!(
+                        headers.get("content-type").unwrap(),
+                        Some("text/plain".to_string()),
+                    );
+                    assert_eq!(
+                        headers.get("Content-Type").unwrap(),
+                        Some("text/plain".to_string()),
+                    );
+                    assert!(headers.get("").is_err());
+                    assert!(headers.set("", "").is_err());
+                    assert!(headers.set("x", "").is_ok());
+                    assert_eq!(headers.get("x").unwrap(), Some(String::new()));
+                    assert!(headers.delete("x").is_ok());
+                    assert_eq!(headers.get("x").unwrap(), None);
+                    assert!(headers.append("a", "y").is_ok());
+                    assert!(headers.append("a", "z").is_ok());
+                    assert_eq!(headers.get("a").unwrap(), Some("y, z".to_string()));
                 }
             "#,
         )