Merge inbound to mozilla-central. a=merge FIREFOX_BETA_62_BASE
authorCosmin Sabou <csabou@mozilla.com>
Mon, 18 Jun 2018 18:52:47 +0300
changeset 808182 9b74b9f2939a7ae3a0ea6e711dc32ed5203e03ff
parent 808181 97eb512f532b933d8b5b72f160815e0727229890 (current diff)
parent 808138 d7079fb3a17993021fd7908af2b22e363d3143e3 (diff)
child 808183 d480328fc72ed05de2abee87879749628e9ae732
child 808203 d8cdfdf5a39bbe6b5f69e209f9512e6a73db82aa
child 808211 87daafd7bbe37890caa1cc25f8ed7498bf7afe82
child 808213 5aec372dfcc4e7ba22cd16fa7eee15ed897a6fb7
child 808214 923e1186d3d0af2f83f27213e3e467c0aea9d84a
child 808216 5ea4bcca74a221821acb7c8362487713ba14b2f5
child 808220 6ed40a925f84a5fe588d23e82eadc5fb144c188d
child 808221 ebb40cb80241d2a9eda1a77f025d32a4e2ed09de
child 808242 681eb7e9d29634d57dc34b08119483ee1745ef11
child 808252 077d33b4449d8506d2a9b847a9d63f2935b64437
child 808266 57f11fc363b88afee58d3daa372ccafb7c38d337
child 808267 180b739b6df6070061109850771908a2402ddfdf
child 808268 c51f923e9826a569741878c63a4af46f3d8f1d44
child 808269 f2582a5386ea023bfb542ccb0b3a830ba1a184cd
child 808274 30f65b3d4971daf93fda9999a510ce741a68c9b5
child 808282 c78969ead8e5000f9defa576433333067d6a2587
child 808283 5550028e6db7a562c0e1cf18291f81eab37175a4
child 808340 ba8541f3429ba7457efdacfdf61605000fea7fa0
child 808437 77e8273ea19ba639d17683463f0246efbae337d2
child 808461 9ec8ca1b9cdc160ddfef55eff1029fc9fd8b28d6
child 808536 17268fee4f09569828438ccb4666af3e9200e123
child 808549 04aaa55244748f64462f7341c1f14654816782c4
child 809167 5f69741c7c076971b6e091651e80a8305e5a31ec
child 809671 e4c83b98f2664b3624e29afab3ec9805099b08d7
child 809719 e341400c1ae707147b4b4c4e0309ea6705df3cbf
child 812714 f87b4940787a94bef70f8473f717236dfa3f8f7e
child 817146 e251fa71750fd79fb1c6185a46cad24319723833
child 817514 c23a2e647922882fc1ca3d7153ec95c5d8a2aa9d
push id113304
push userbmo:nchen@mozilla.com
push dateMon, 18 Jun 2018 16:45:39 +0000
reviewersmerge
milestone62.0a1
Merge inbound to mozilla-central. a=merge
servo/components/nonzero/Cargo.toml
servo/components/nonzero/lib.rs
servo/components/servo/Cargo.toml
servo/components/servo/lib.rs
third_party/rust/proc-macro2-0.2.2/.cargo-checksum.json
third_party/rust/proc-macro2-0.2.2/.travis.yml
third_party/rust/proc-macro2-0.2.2/Cargo.toml
third_party/rust/proc-macro2-0.2.2/LICENSE-APACHE
third_party/rust/proc-macro2-0.2.2/LICENSE-MIT
third_party/rust/proc-macro2-0.2.2/README.md
third_party/rust/proc-macro2-0.2.2/src/lib.rs
third_party/rust/proc-macro2-0.2.2/src/macros.rs
third_party/rust/proc-macro2-0.2.2/src/stable.rs
third_party/rust/proc-macro2-0.2.2/src/strnom.rs
third_party/rust/proc-macro2-0.2.2/src/unstable.rs
third_party/rust/proc-macro2-0.2.2/tests/test.rs
third_party/rust/quote-0.4.2/.cargo-checksum.json
third_party/rust/quote-0.4.2/Cargo.toml
third_party/rust/quote-0.4.2/LICENSE-APACHE
third_party/rust/quote-0.4.2/LICENSE-MIT
third_party/rust/quote-0.4.2/README.md
third_party/rust/quote-0.4.2/src/lib.rs
third_party/rust/quote-0.4.2/src/to_tokens.rs
third_party/rust/quote-0.4.2/src/tokens.rs
third_party/rust/quote-0.4.2/tests/test.rs
third_party/rust/syn-0.12.12/.cargo-checksum.json
third_party/rust/syn-0.12.12/Cargo.toml
third_party/rust/syn-0.12.12/LICENSE-APACHE
third_party/rust/syn-0.12.12/LICENSE-MIT
third_party/rust/syn-0.12.12/README.md
third_party/rust/syn-0.12.12/src/attr.rs
third_party/rust/syn-0.12.12/src/buffer.rs
third_party/rust/syn-0.12.12/src/data.rs
third_party/rust/syn-0.12.12/src/derive.rs
third_party/rust/syn-0.12.12/src/error.rs
third_party/rust/syn-0.12.12/src/expr.rs
third_party/rust/syn-0.12.12/src/file.rs
third_party/rust/syn-0.12.12/src/gen/fold.rs
third_party/rust/syn-0.12.12/src/gen/visit.rs
third_party/rust/syn-0.12.12/src/gen/visit_mut.rs
third_party/rust/syn-0.12.12/src/gen_helper.rs
third_party/rust/syn-0.12.12/src/generics.rs
third_party/rust/syn-0.12.12/src/ident.rs
third_party/rust/syn-0.12.12/src/item.rs
third_party/rust/syn-0.12.12/src/lib.rs
third_party/rust/syn-0.12.12/src/lifetime.rs
third_party/rust/syn-0.12.12/src/lit.rs
third_party/rust/syn-0.12.12/src/mac.rs
third_party/rust/syn-0.12.12/src/macros.rs
third_party/rust/syn-0.12.12/src/op.rs
third_party/rust/syn-0.12.12/src/parse_quote.rs
third_party/rust/syn-0.12.12/src/parsers.rs
third_party/rust/syn-0.12.12/src/path.rs
third_party/rust/syn-0.12.12/src/punctuated.rs
third_party/rust/syn-0.12.12/src/spanned.rs
third_party/rust/syn-0.12.12/src/synom.rs
third_party/rust/syn-0.12.12/src/token.rs
third_party/rust/syn-0.12.12/src/tt.rs
third_party/rust/syn-0.12.12/src/ty.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -469,27 +469,27 @@ dependencies = [
  "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cstr"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "cstr-macros 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cstr-macros 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "procedural-masquerade 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cstr-macros"
-version = "0.1.2"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "procedural-masquerade 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "cubeb"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "cubeb-core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -529,41 +529,42 @@ source = "registry+https://github.com/ru
 dependencies = [
  "cmake 0.1.29 (registry+https://github.com/rust-lang/crates.io-index)",
  "gcc 0.3.54 (registry+https://github.com/rust-lang/crates.io-index)",
  "pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "darling"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "darling_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "darling_macro 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "darling_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "darling_macro 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "darling_core"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "ident_case 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.3.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "darling_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "darling_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "devd-rs"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "libc 0.2.39 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1147,19 +1148,19 @@ dependencies = [
  "smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "malloc_size_of_derive"
 version = "0.0.1"
 dependencies = [
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "synstructure 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synstructure 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "matches"
 version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -1585,24 +1586,16 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "prefs_parser"
 version = "0.0.1"
 
 [[package]]
 name = "proc-macro2"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "proc-macro2"
 version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "procedural-masquerade"
@@ -1631,24 +1624,16 @@ source = "registry+https://github.com/ru
 
 [[package]]
 name = "quote"
 version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "quote"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "quote"
 version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "rand"
@@ -1968,20 +1953,20 @@ dependencies = [
  "void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "walkdir 2.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "style_derive"
 version = "0.0.1"
 dependencies = [
- "darling 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
- "synstructure 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "darling 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synstructure 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "style_traits"
 version = "0.0.1"
 dependencies = [
  "app_units 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bitflags 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2011,42 +1996,32 @@ dependencies = [
  "size_of_test 0.0.1",
  "smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "style 0.0.1",
  "style_traits 0.0.1",
 ]
 
 [[package]]
 name = "syn"
-version = "0.12.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "syn"
 version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "synstructure"
-version = "0.7.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "tempdir"
 version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
@@ -2554,24 +2529,24 @@ dependencies = [
 "checksum cose-c 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "49726015ab0ca765144fcca61e4a7a543a16b795a777fa53f554da2fffff9a94"
 "checksum crc 1.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bd5d02c0aac6bd68393ed69e00bbc2457f3e89075c6349db7189618dc4ddc1d7"
 "checksum crossbeam-deque 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f739f8c5363aca78cfb059edf753d8f0d36908c348f3d8d1503f03d8b75d9cf3"
 "checksum crossbeam-epoch 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "927121f5407de9956180ff5e936fe3cf4324279280001cd56b669d28ee7e9150"
 "checksum crossbeam-utils 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "2760899e32a1d58d5abb31129f8fae5de75220bc2176e77ff7c627ae45c918d9"
 "checksum cssparser 0.23.9 (registry+https://github.com/rust-lang/crates.io-index)" = "205647ffe2b63a9726a4c3bb6f31c7325e8ceff10e2f1b75a6fb7609e20419ea"
 "checksum cssparser-macros 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "f3a5383ae18dbfdeb569ed62019f5bddb2a95cd2d3833313c475a0d014777805"
 "checksum cstr 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "b6557bdb1dc9647eae1cf7f5601b14cd45fc3c7ccf2df618387416fe542da6ea"
-"checksum cstr-macros 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "f9f316203d1ea36f4f18316822806f6999aa3dc5ed1adf51e35b77e3b3933d78"
+"checksum cstr-macros 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "0472c17c83d3ec1af32fb6ee2b3ad56ae0b6e69355d63d1d30602055c34324a8"
 "checksum cubeb 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "8a3502aafa1bf95c524f65d2ba46d8741700c6a8a9543ea52c6da3d8b69a2896"
 "checksum cubeb-backend 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fdcac95519416d9ec814db2dc40e6293e7da25b906023d93f48b87f0587ab138"
 "checksum cubeb-core 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "37f7b20f757a4e4b6aa28863236551bff77682dc6db192eba15af615492b5445"
 "checksum cubeb-sys 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "653b9e245d35dbe2a2da7c4586275cee75ff656ddeb02d4a73b4afdfa6d67502"
-"checksum darling 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d3effd06d4057f275cb7858889f4952920bab78dd8ff0f6e7dfe0c8d2e67ed89"
-"checksum darling_core 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "167dd3e235c2f1da16a635c282630452cdf49191eb05711de1bcd1d3d5068c00"
-"checksum darling_macro 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c53edaba455f6073a10c27c72440860eb3f60444f8c8660a391032eeae744d82"
+"checksum darling 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "2a78af487e4eb8f4421a1770687b328af6bb4494ca93435210678c6eea875c11"
+"checksum darling_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b315f49c7b6db3708bca6e6913c194581a44ec619b7a39e131d4dd63733a3698"
+"checksum darling_macro 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "eb69a38fdeaeaf3db712e1df170de67ee9dfc24fb88ca3e9d21e703ec25a4d8e"
 "checksum devd-rs 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "e7c9ac481c38baf400d3b732e4a06850dfaa491d1b6379a249d9d40d14c2434c"
 "checksum diff 0.1.11 (registry+https://github.com/rust-lang/crates.io-index)" = "3c2b69f912779fbb121ceb775d74d51e915af17aaebc38d28a592843a2dd0a3a"
 "checksum docopt 0.8.3 (registry+https://github.com/rust-lang/crates.io-index)" = "d8acd393692c503b168471874953a2531df0e9ab77d0b6bbc582395743300a4a"
 "checksum dtoa 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "09c3753c3db574d215cba4ea76018483895d7bff25a31b49ba45db21c48e50ab"
 "checksum dtoa-short 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "068d4026697c1a18f0b0bb8cfcad1b0c151b90d8edb9bf4c235ad68128920d1d"
 "checksum dwrote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "b26e30aaa6bf31ec830db15fec14ed04f0f2ecfcc486ecfce88c55d3389b237f"
 "checksum either 1.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "18785c1ba806c258137c937e44ada9ee7e69a37e3c72077542cd2f069d78562a"
 "checksum ena 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "cabe5a5078ac8c506d3e4430763b1ba9b609b1286913e7d08e581d1c2de9b7e5"
@@ -2658,22 +2633,20 @@ dependencies = [
 "checksum phf 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "cb325642290f28ee14d8c6201159949a872f220c62af6e110a56ea914fbe42fc"
 "checksum phf_codegen 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "d62594c0bb54c464f633175d502038177e90309daf2e0158be42ed5f023ce88f"
 "checksum phf_generator 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "6b07ffcc532ccc85e3afc45865469bf5d9e4ef5bfcf9622e3cfe80c2d275ec03"
 "checksum phf_shared 0.7.21 (registry+https://github.com/rust-lang/crates.io-index)" = "07e24b0ca9643bdecd0632f2b3da6b1b89bbb0030e0b992afc1113b23a7bc2f2"
 "checksum pkg-config 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)" = "3a8b4c6b8165cd1a1cd4b9b120978131389f64bdaf456435caa41e630edba903"
 "checksum plane-split 0.9.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7079b8485b4f9d9560dee7a69ca8f6ca781f9f284ff9d2bf27255d440b03e4af"
 "checksum podio 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "e5422a1ee1bc57cc47ae717b0137314258138f38fd5f3cea083f43a9725383a0"
 "checksum precomputed-hash 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c"
-"checksum proc-macro2 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d1cb7aaaa4bf022ec2b14ff2f2ba1643a22f3cee88df014a85e14b392282c61d"
 "checksum proc-macro2 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "49b6a521dc81b643e9a51e0d1cf05df46d5a2f3c0280ea72bcb68276ba64a118"
 "checksum procedural-masquerade 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9f566249236c6ca4340f7ca78968271f0ed2b0f234007a61b66f9ecd0af09260"
 "checksum quick-error 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "eda5fe9b71976e62bc81b781206aaa076401769b2143379d3eb2118388babac4"
 "checksum quote 0.3.15 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6e920b65c65f10b2ae65c831a81a073a89edd28c7cce89475bff467ab4167a"
-"checksum quote 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1eca14c727ad12702eb4b6bfb5a232287dcf8385cb8ca83a3eeaf6519c44c408"
 "checksum quote 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8"
 "checksum rand 0.3.18 (registry+https://github.com/rust-lang/crates.io-index)" = "6475140dfd8655aeb72e1fd4b7a1cc1c202be65d71669476e392fe62532b9edd"
 "checksum rayon 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "485541959c8ecc49865526fe6c4de9653dd6e60d829d6edf0be228167b60372d"
 "checksum rayon-core 1.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9d24ad214285a7729b174ed6d3bcfcb80177807f959d95fafd5bfc5c4f201ac8"
 "checksum redox_syscall 0.1.32 (registry+https://github.com/rust-lang/crates.io-index)" = "ab105df655884ede59d45b7070c8a65002d921461ee813a024558ca16030eea0"
 "checksum regex 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1731164734096285ec2a5ec7fea5248ae2f5485b3feeb0115af4fda2183b2d1b"
 "checksum regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "75ecf88252dce580404a22444fc7d626c01815debba56a7f4f536772a5ff19d3"
 "checksum regex-syntax 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)" = "ad890a5eef7953f55427c50575c680c42841653abd2b028b68cd223d157f62db"
@@ -2697,19 +2670,18 @@ dependencies = [
 "checksum smallbitvec 2.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "5c63726029f0069f88467873e47f392575f28f9f16b72ac65465263db4b3a13c"
 "checksum smallvec 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "44db0ecb22921ef790d17ae13a3f6d15784183ff5f2a01aa32098c7498d2b4b9"
 "checksum stable_deref_trait 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "15132e0e364248108c5e2c02e3ab539be8d6f5d52a01ca9bbf27ed657316f02b"
 "checksum string_cache 0.7.3 (registry+https://github.com/rust-lang/crates.io-index)" = "25d70109977172b127fe834e5449e5ab1740b9ba49fa18a2020f509174f25423"
 "checksum string_cache_codegen 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "479cde50c3539481f33906a387f2bd17c8e87cb848c35b6021d41fb81ff9b4d7"
 "checksum string_cache_shared 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b1884d1bc09741d466d9b14e6d37ac89d6909cbcac41dd9ae982d4d063bbedfc"
 "checksum strsim 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b4d15c810519a91cf877e7e36e63fe068815c678181439f2f29e2562147c3694"
 "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
-"checksum syn 0.12.12 (registry+https://github.com/rust-lang/crates.io-index)" = "9e1c669ed757c0ebd04337f6a5bb972d05e0c08fe2540dd3ee3dd9e4daf1604c"
 "checksum syn 0.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "91b52877572087400e83d24b9178488541e3d535259e04ff17a63df1e5ceff59"
-"checksum synstructure 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "010366096045d8250555904c58da03377289e7f4b2ce7a5b1027e2b532f41000"
+"checksum synstructure 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "98cad891cd238c98e1f0aec9f7c0f620aa696e4e5f7daba56ac67b5e86a6b049"
 "checksum tempdir 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "87974a6f5c1dfb344d733055601650059a3363de2a6104819293baff662132d6"
 "checksum term 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "fa63644f74ce96fbeb9b794f66aff2a52d601cbd5e80f4b97123e3899f4570f1"
 "checksum term_size 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "e2b6b55df3198cc93372e85dd2ed817f0e38ce8cc0f22eb32391bfad9c4bf209"
 "checksum termcolor 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "adc4587ead41bf016f11af03e55a624c06568b5a19db4e90fde573d805074f83"
 "checksum textwrap 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c0b59b6b4b44d867f1370ef1bd91bfb262bf07bf0ae65c202ea2fbc16153b693"
 "checksum thread_local 0.3.5 (registry+https://github.com/rust-lang/crates.io-index)" = "279ef31c19ededf577bfd12dfae728040a21f635b06a24cd670ff510edd38963"
 "checksum thread_profiler 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "cf947d192a9be60ef5131cc7a4648886ba89d712f16700ebbf80c8a69d05d48f"
 "checksum time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)" = "d825be0eb33fda1a7e68012d51e9c7f451dc1a69391e7fdc197060bb8c56667b"
--- a/dom/media/BufferReader.h
+++ b/dom/media/BufferReader.h
@@ -14,17 +14,22 @@
 
 namespace mozilla {
 
 extern mozilla::LazyLogModule gMP4MetadataLog;
 
 class MOZ_RAII BufferReader
 {
 public:
-  BufferReader() : mPtr(nullptr), mRemaining(0) {}
+  BufferReader()
+    : mPtr(nullptr)
+    , mRemaining(0)
+    , mLength(0)
+  {
+  }
   BufferReader(const uint8_t* aData, size_t aSize)
     : mPtr(aData), mRemaining(aSize), mLength(aSize)
   {
   }
   template<size_t S>
   explicit BufferReader(const AutoTArray<uint8_t, S>& aData)
     : mPtr(aData.Elements()), mRemaining(aData.Length()), mLength(aData.Length())
   {
--- a/dom/media/DOMMediaStream.cpp
+++ b/dom/media/DOMMediaStream.cpp
@@ -422,17 +422,17 @@ NS_INTERFACE_MAP_END_INHERITING(DOMMedia
 
 DOMMediaStream::DOMMediaStream(nsPIDOMWindowInner* aWindow,
                                MediaStreamTrackSourceGetter* aTrackSourceGetter)
   : mLogicalStreamStartTime(0), mWindow(aWindow),
     mInputStream(nullptr), mOwnedStream(nullptr), mPlaybackStream(nullptr),
     mTracksPendingRemoval(0), mTrackSourceGetter(aTrackSourceGetter),
     mPlaybackTrackListener(MakeAndAddRef<PlaybackTrackListener>(this)),
     mTracksCreated(false), mNotifiedOfMediaStreamGraphShutdown(false),
-    mActive(false), mSetInactiveOnFinish(false)
+    mActive(false), mSetInactiveOnFinish(false), mCORSMode(CORS_NONE)
 {
   nsresult rv;
   nsCOMPtr<nsIUUIDGenerator> uuidgen =
     do_GetService("@mozilla.org/uuid-generator;1", &rv);
 
   if (NS_SUCCEEDED(rv) && uuidgen) {
     nsID uuid;
     memset(&uuid, 0, sizeof(uuid));
--- a/dom/media/GetUserMediaRequest.cpp
+++ b/dom/media/GetUserMediaRequest.cpp
@@ -27,18 +27,22 @@ GetUserMediaRequest::GetUserMediaRequest
   , mIsHandlingUserInput(aIsHandlingUserInput)
 {
 }
 
 GetUserMediaRequest::GetUserMediaRequest(
     nsPIDOMWindowInner* aInnerWindow,
     const nsAString& aRawId,
     const nsAString& aMediaSource)
-  : mRawID(aRawId)
+  : mInnerWindowID(0)
+  , mOuterWindowID(0)
+  , mRawID(aRawId)
   , mMediaSource(aMediaSource)
+  , mIsSecure(false)
+  , mIsHandlingUserInput(false)
 {
   if (aInnerWindow && aInnerWindow->GetOuterWindow()) {
     mOuterWindowID = aInnerWindow->GetOuterWindow()->WindowID();
   }
 }
 
 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_0(GetUserMediaRequest)
 NS_IMPL_CYCLE_COLLECTING_ADDREF(GetUserMediaRequest)
--- a/dom/media/MediaCache.cpp
+++ b/dom/media/MediaCache.cpp
@@ -517,16 +517,17 @@ MediaCacheStream::MediaCacheStream(Chann
   : mMediaCache(nullptr)
   , mClient(aClient)
   , mIsTransportSeekable(false)
   , mCacheSuspended(false)
   , mChannelEnded(false)
   , mStreamOffset(0)
   , mPlaybackBytesPerSecond(10000)
   , mPinCount(0)
+  , mNotifyDataEndedStatus(NS_ERROR_NOT_INITIALIZED)
   , mMetadataInPartialBlockBuffer(false)
   , mIsPrivateBrowsing(aIsPrivateBrowsing)
 {
 }
 
 size_t MediaCacheStream::SizeOfExcludingThis(
                                 MallocSizeOf aMallocSizeOf) const
 {
--- a/dom/media/MediaCache.h
+++ b/dom/media/MediaCache.h
@@ -411,17 +411,22 @@ private:
 #else
     void Verify() {}
 #endif
 
     size_t SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
 
   private:
     struct Entry : public nsUint32HashKey {
-      explicit Entry(KeyTypePointer aKey) : nsUint32HashKey(aKey) { }
+      explicit Entry(KeyTypePointer aKey)
+        : nsUint32HashKey(aKey)
+        , mNextBlock(0)
+        , mPrevBlock(0)
+      {
+      }
       Entry(const Entry& toCopy) : nsUint32HashKey(&toCopy.GetKey()),
         mNextBlock(toCopy.mNextBlock), mPrevBlock(toCopy.mPrevBlock) {}
 
       int32_t mNextBlock;
       int32_t mPrevBlock;
     };
     nsTHashtable<Entry> mEntries;
 
--- a/dom/media/MediaDecoderStateMachine.cpp
+++ b/dom/media/MediaDecoderStateMachine.cpp
@@ -815,17 +815,20 @@ private:
  *   COMPLETED if the new playback position is the end of the media resource.
  *   NextFrameSeekingState if completing a NextFrameSeekingFromDormantState.
  *   DECODING otherwise.
  */
 class MediaDecoderStateMachine::SeekingState
   : public MediaDecoderStateMachine::StateObject
 {
 public:
-  explicit SeekingState(Master* aPtr) : StateObject(aPtr) { }
+  explicit SeekingState(Master* aPtr)
+    : StateObject(aPtr)
+    , mVisibility(static_cast<EventVisibility>(0))
+  { }
 
   RefPtr<MediaDecoder::SeekPromise> Enter(SeekJob&& aSeekJob,
                                           EventVisibility aVisibility)
   {
     mSeekJob = std::move(aSeekJob);
     mVisibility = aVisibility;
 
     // Suppressed visibility comes from two cases: (1) leaving dormant state,
--- a/dom/media/MediaRecorder.cpp
+++ b/dom/media/MediaRecorder.cpp
@@ -1251,29 +1251,35 @@ MediaRecorder::~MediaRecorder()
   UnRegisterActivityObserver();
 }
 
 MediaRecorder::MediaRecorder(DOMMediaStream& aSourceMediaStream,
                              nsPIDOMWindowInner* aOwnerWindow)
   : DOMEventTargetHelper(aOwnerWindow)
   , mAudioNodeOutput(0)
   , mState(RecordingState::Inactive)
+  , mAudioBitsPerSecond(0)
+  , mVideoBitsPerSecond(0)
+  , mBitsPerSecond(0)
 {
   MOZ_ASSERT(aOwnerWindow);
   mDOMStream = &aSourceMediaStream;
 
   RegisterActivityObserver();
 }
 
 MediaRecorder::MediaRecorder(AudioNode& aSrcAudioNode,
                              uint32_t aSrcOutput,
                              nsPIDOMWindowInner* aOwnerWindow)
   : DOMEventTargetHelper(aOwnerWindow)
   , mAudioNodeOutput(aSrcOutput)
   , mState(RecordingState::Inactive)
+  , mAudioBitsPerSecond(0)
+  , mVideoBitsPerSecond(0)
+  , mBitsPerSecond(0)
 {
   MOZ_ASSERT(aOwnerWindow);
 
   mAudioNode = &aSrcAudioNode;
 
   RegisterActivityObserver();
 }
 
--- a/dom/media/MediaStreamGraph.cpp
+++ b/dom/media/MediaStreamGraph.cpp
@@ -3595,16 +3595,17 @@ ProcessedMediaStream::DestroyImpl()
   // MediaStreamGraphImpl::RemoveStreamGraphThread() will also call
   // SetStreamOrderDirty(), for other reasons.
 }
 
 MediaStreamGraphImpl::MediaStreamGraphImpl(GraphDriverType aDriverRequested,
                                            TrackRate aSampleRate,
                                            AbstractThread* aMainThread)
   : MediaStreamGraph(aSampleRate)
+  , mFirstCycleBreaker(0)
   , mPortCount(0)
   , mInputWanted(false)
   , mInputDeviceID(-1)
   , mOutputWanted(true)
   , mOutputDeviceID(-1)
   , mNeedAnotherIteration(false)
   , mGraphDriverAsleep(false)
   , mMonitor("MediaStreamGraphImpl")
--- a/dom/media/StreamTracks.h
+++ b/dom/media/StreamTracks.h
@@ -245,17 +245,22 @@ public:
 
   class MOZ_STACK_CLASS TrackIter final
   {
   public:
     /**
      * Iterate through the tracks of aBuffer in order of ID.
      */
     explicit TrackIter(const StreamTracks& aBuffer) :
-      mBuffer(&aBuffer.mTracks), mIndex(0), mMatchType(false) {}
+      mBuffer(&aBuffer.mTracks),
+      mIndex(0),
+      mType(static_cast<MediaSegment::Type>(0)),
+      mMatchType(false)
+      {
+      }
     /**
      * Iterate through the tracks of aBuffer with type aType, in order of ID.
      */
     TrackIter(const StreamTracks& aBuffer, MediaSegment::Type aType) :
       mBuffer(&aBuffer.mTracks), mIndex(0), mType(aType), mMatchType(true) { FindMatch(); }
     bool IsEnded() const { return mIndex >= mBuffer->Length(); }
     void Next()
     {
--- a/dom/media/Tracing.cpp
+++ b/dom/media/Tracing.cpp
@@ -56,16 +56,17 @@ AutoTracer::AutoTracer(AsyncLogger& aLog
                        const char* aLocation,
                        uint64_t aPID,
                        uint64_t aTID,
                        EventType aEventType,
                        uint64_t aFrames,
                        uint64_t aSampleRate)
   : mLogger(aLogger)
   , mLocation(aLocation)
+  , mComment(nullptr)
   , mEventType(aEventType)
   , mPID(aPID)
   , mTID(aTID)
 {
   MOZ_ASSERT(aEventType == EventType::BUDGET);
 
   if (aLogger.Enabled()) {
     float durationUS = (static_cast<float>(aFrames) / aSampleRate) * 1e6;
--- a/dom/media/VideoUtils.h
+++ b/dom/media/VideoUtils.h
@@ -481,16 +481,19 @@ public:
     DereferencedType operator*()
     {
       return Substring(mStart, mEnd);
     }
   private:
     friend class StringListRange;
     Iterator(const CharType* aRangeStart, uint32_t aLength)
       : mRangeEnd(aRangeStart + aLength)
+      , mStart(nullptr)
+      , mEnd(nullptr)
+      , mComma(nullptr)
     {
       SearchItemAt(aRangeStart);
     }
     void SearchItemAt(Pointer start)
     {
       // First, skip leading whitespace.
       for (Pointer p = start; ; ++p) {
         if (p >= mRangeEnd) {
--- a/dom/media/eme/MediaKeyMessageEvent.cpp
+++ b/dom/media/eme/MediaKeyMessageEvent.cpp
@@ -35,16 +35,17 @@ NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_IN
   mozilla::DropJSObjects(this);
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MediaKeyMessageEvent)
 NS_INTERFACE_MAP_END_INHERITING(Event)
 
 MediaKeyMessageEvent::MediaKeyMessageEvent(EventTarget* aOwner)
   : Event(aOwner, nullptr, nullptr)
+  , mMessageType(static_cast<MediaKeyMessageType>(0))
 {
   mozilla::HoldJSObjects(this);
 }
 
 MediaKeyMessageEvent::~MediaKeyMessageEvent()
 {
   mMessage = nullptr;
   mozilla::DropJSObjects(this);
--- a/dom/media/encoder/TrackEncoder.h
+++ b/dom/media/encoder/TrackEncoder.h
@@ -218,16 +218,17 @@ protected:
 class AudioTrackEncoder : public TrackEncoder
 {
 public:
   explicit AudioTrackEncoder(TrackRate aTrackRate)
     : TrackEncoder(aTrackRate)
     , mChannels(0)
     , mSamplingRate(0)
     , mAudioBitrate(0)
+    , mDirectConnected(false)
   {}
 
   /**
    * Suspends encoding from mCurrentTime, i.e., all audio data until the next
    * Resume() will be dropped.
    */
   void Suspend(TimeStamp aTime) override;
 
--- a/dom/media/gmp/GMPContentParent.cpp
+++ b/dom/media/gmp/GMPContentParent.cpp
@@ -29,16 +29,17 @@ extern LogModule* GetGMPLog();
 #undef __CLASS__
 #endif
 #define __CLASS__ "GMPContentParent"
 
 namespace gmp {
 
 GMPContentParent::GMPContentParent(GMPParent* aParent)
   : mParent(aParent)
+  , mPluginId(0)
 {
   if (mParent) {
     SetDisplayName(mParent->GetDisplayName());
     SetPluginId(mParent->GetPluginId());
   }
 }
 
 GMPContentParent::~GMPContentParent()
--- a/dom/media/gmp/GMPTimerParent.h
+++ b/dom/media/gmp/GMPTimerParent.h
@@ -30,17 +30,18 @@ protected:
   void ActorDestroy(ActorDestroyReason aWhy) override;
 
 private:
   ~GMPTimerParent() {}
 
   static void GMPTimerExpired(nsITimer *aTimer, void *aClosure);
 
   struct Context {
-    Context() {
+    Context()
+      : mId(0) {
       MOZ_COUNT_CTOR(Context);
     }
     ~Context() {
       MOZ_COUNT_DTOR(Context);
     }
     nsCOMPtr<nsITimer> mTimer;
     RefPtr<GMPTimerParent> mParent; // Note: live timers keep the GMPTimerParent alive.
     uint32_t mId;
--- a/dom/media/ipc/RemoteVideoDecoder.cpp
+++ b/dom/media/ipc/RemoteVideoDecoder.cpp
@@ -20,16 +20,18 @@ namespace dom {
 using base::Thread;
 using namespace ipc;
 using namespace layers;
 using namespace gfx;
 
 RemoteVideoDecoder::RemoteVideoDecoder()
   : mActor(new VideoDecoderChild())
   , mDescription("RemoteVideoDecoder")
+  , mIsHardwareAccelerated(false)
+  , mConversion(MediaDataDecoder::ConversionRequired::kNeedNone)
 {
 }
 
 RemoteVideoDecoder::~RemoteVideoDecoder()
 {
   // We're about to be destroyed and drop our ref to
   // VideoDecoderChild. Make sure we put a ref into the
   // task queue for the VideoDecoderChild thread to keep
--- a/dom/media/mp4/Box.cpp
+++ b/dom/media/mp4/Box.cpp
@@ -118,16 +118,18 @@ Box::Box(BoxContext* aContext, uint64_t 
     return;
   }
 
   mRange = boxRange;
 }
 
 Box::Box()
   : mContext(nullptr)
+  , mBodyOffset(0)
+  , mChildOffset(0)
   , mParent(nullptr)
 {}
 
 Box
 Box::Next() const
 {
   MOZ_ASSERT(IsAvailable());
   return Box(mContext, mRange.mEnd, mParent);
--- a/dom/media/mp4/MP4Demuxer.cpp
+++ b/dom/media/mp4/MP4Demuxer.cpp
@@ -123,16 +123,17 @@ AccumulateSPSTelemetry(const MediaByteBu
   }
 
   return true;
 }
 
 MP4Demuxer::MP4Demuxer(MediaResource* aResource)
   : mResource(aResource)
   , mStream(new ResourceStream(aResource))
+  , mIsSeekable(false)
 {
   DDLINKCHILD("resource", aResource);
   DDLINKCHILD("stream", mStream.get());
 }
 
 RefPtr<MP4Demuxer::InitPromise>
 MP4Demuxer::Init()
 {
--- a/dom/media/mp4/MP4Metadata.cpp
+++ b/dom/media/mp4/MP4Metadata.cpp
@@ -21,16 +21,17 @@
 
 using mozilla::media::TimeUnit;
 
 namespace mozilla {
 LazyLogModule gMP4MetadataLog("MP4Metadata");
 
 IndiceWrapper::IndiceWrapper(Mp4parseByteData& aIndice)
 {
+  mIndice.data = nullptr;
   mIndice.length = aIndice.length;
   mIndice.indices = aIndice.indices;
 }
 
 size_t
 IndiceWrapper::Length() const
 {
   return mIndice.length;
--- a/dom/media/mp4/MoofParser.cpp
+++ b/dom/media/mp4/MoofParser.cpp
@@ -682,16 +682,17 @@ Moof::ParseTrun(Box& aBox, Tfhd& aTfhd, 
   mMaxRoundingError += roundTime;
 
   *aDecodeTime = decodeTime;
 
   return Ok();
 }
 
 Tkhd::Tkhd(Box& aBox)
+  : mTrackId(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Tkhd, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
@@ -722,16 +723,20 @@ Tkhd::Parse(Box& aBox)
     MOZ_TRY_VAR(reserved, reader->ReadU32());
     NS_ASSERTION(!reserved, "reserved should be 0");
     MOZ_TRY_VAR(mDuration, reader->ReadU64());
   }
   return Ok();
 }
 
 Mvhd::Mvhd(Box& aBox)
+  : mCreationTime(0)
+  , mModificationTime(0)
+  , mTimescale(0)
+  , mDuration(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Mvhd, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
@@ -764,16 +769,22 @@ Mvhd::Parse(Box& aBox)
 }
 
 Mdhd::Mdhd(Box& aBox)
   : Mvhd(aBox)
 {
 }
 
 Trex::Trex(Box& aBox)
+  : mFlags(0)
+  , mTrackId(0)
+  , mDefaultSampleDescriptionIndex(0)
+  , mDefaultSampleDuration(0)
+  , mDefaultSampleSize(0)
+  , mDefaultSampleFlags(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Trex, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
@@ -788,16 +799,17 @@ Trex::Parse(Box& aBox)
   MOZ_TRY_VAR(mDefaultSampleSize, reader->ReadU32());
   MOZ_TRY_VAR(mDefaultSampleFlags, reader->ReadU32());
 
   return Ok();
 }
 
 Tfhd::Tfhd(Box& aBox, Trex& aTrex)
   : Trex(aTrex)
+  , mBaseDataOffset(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Tfhd, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
@@ -827,16 +839,17 @@ Tfhd::Parse(Box& aBox)
   if (mFlags & 0x20) {
     MOZ_TRY_VAR(mDefaultSampleFlags, reader->ReadU32());
   }
 
   return Ok();
 }
 
 Tfdt::Tfdt(Box& aBox)
+  : mBaseMediaDecodeTime(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Tfdt, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
@@ -994,16 +1007,17 @@ Saio::Parse(Box& aBox)
       MOZ_TRY_VAR(offset, reader->ReadU64());
       MOZ_ALWAYS_TRUE(mOffsets.AppendElement(offset, fallible));
     }
   }
   return Ok();
 }
 
 Sbgp::Sbgp(Box& aBox)
+  : mGroupingTypeParam(0)
 {
   mValid = Parse(aBox).isOk();
   if (!mValid) {
     LOG(Sbgp, "Parse failed");
   }
 }
 
 Result<Ok, nsresult>
--- a/dom/media/ogg/OggWriter.cpp
+++ b/dom/media/ogg/OggWriter.cpp
@@ -6,17 +6,21 @@
 #include "prtime.h"
 #include "GeckoProfiler.h"
 
 #undef LOG
 #define LOG(args, ...)
 
 namespace mozilla {
 
-OggWriter::OggWriter() : ContainerWriter()
+OggWriter::OggWriter()
+  : ContainerWriter()
+  , mOggStreamState()
+  , mOggPage()
+  , mPacket()
 {
   if (NS_FAILED(Init())) {
     LOG("ERROR! Fail to initialize the OggWriter.");
   }
 }
 
 OggWriter::~OggWriter()
 {
--- a/dom/media/ogg/OpusParser.cpp
+++ b/dom/media/ogg/OpusParser.cpp
@@ -27,17 +27,18 @@ OpusParser::OpusParser():
   mPreSkip(0),
 #ifdef MOZ_SAMPLE_TYPE_FLOAT32
   mGain(1.0f),
 #else
   mGain_Q16(65536),
 #endif
   mChannelMapping(0),
   mStreams(0),
-  mCoupledStreams(0)
+  mCoupledStreams(0),
+  mPrevPacketGranulepos(0)
 { }
 
 bool OpusParser::DecodeHeader(unsigned char* aData, size_t aLength)
 {
     if (aLength < 19 || memcmp(aData, "OpusHead", 8)) {
       OPUS_LOG(LogLevel::Debug, ("Invalid Opus file: unrecognized header"));
       return false;
     }
--- a/dom/media/platforms/agnostic/TheoraDecoder.cpp
+++ b/dom/media/platforms/agnostic/TheoraDecoder.cpp
@@ -42,16 +42,18 @@ ogg_packet InitTheoraPacket(const unsign
   packet.packetno = aPacketNo;
   return packet;
 }
 
 TheoraDecoder::TheoraDecoder(const CreateDecoderParams& aParams)
   : mImageAllocator(aParams.mKnowsCompositor)
   , mImageContainer(aParams.mImageContainer)
   , mTaskQueue(aParams.mTaskQueue)
+  , mTheoraInfo{}
+  , mTheoraComment{}
   , mTheoraSetupInfo(nullptr)
   , mTheoraDecoderContext(nullptr)
   , mPacketCount(0)
   , mInfo(aParams.VideoConfig())
 {
   MOZ_COUNT_CTOR(TheoraDecoder);
 }
 
--- a/dom/media/platforms/apple/AppleATDecoder.cpp
+++ b/dom/media/platforms/apple/AppleATDecoder.cpp
@@ -23,16 +23,17 @@
 namespace mozilla {
 
 AppleATDecoder::AppleATDecoder(const AudioInfo& aConfig,
                                TaskQueue* aTaskQueue)
   : mConfig(aConfig)
   , mFileStreamError(false)
   , mTaskQueue(aTaskQueue)
   , mConverter(nullptr)
+  , mOutputFormat()
   , mStream(nullptr)
   , mParsedFramesForAACMagicCookie(0)
   , mErrored(false)
 {
   MOZ_COUNT_CTOR(AppleATDecoder);
   LOG("Creating Apple AudioToolbox decoder");
   LOG("Audio Decoder configuration: %s %d Hz %d channels %d bits per channel",
       mConfig.mMimeType.get(),
--- a/dom/media/wave/WaveDemuxer.cpp
+++ b/dom/media/wave/WaveDemuxer.cpp
@@ -72,20 +72,22 @@ WAVDemuxer::IsSeekable() const
 // WAVTrackDemuxer
 
 WAVTrackDemuxer::WAVTrackDemuxer(MediaResource* aSource)
   : mSource(aSource)
   , mOffset(0)
   , mFirstChunkOffset(0)
   , mNumParsedChunks(0)
   , mChunkIndex(0)
+  , mDataLength(0)
   , mTotalChunkLen(0)
   , mSamplesPerChunk(0)
   , mSamplesPerSecond(0)
   , mChannels(0)
+  , mSampleFormat(0)
 {
   DDLINKCHILD("source", aSource);
   Reset();
 }
 
 bool
 WAVTrackDemuxer::Init()
 {
--- a/dom/media/webm/EbmlComposer.cpp
+++ b/dom/media/webm/EbmlComposer.cpp
@@ -220,13 +220,15 @@ EbmlComposer::ExtractBuffer(nsTArray<nsT
 EbmlComposer::EbmlComposer()
   : mFlushState(FLUSH_NONE)
   , mClusterHeaderIndex(0)
   , mClusterLengthLoc(0)
   , mCodecDelay(0)
   , mClusterTimecode(0)
   , mWidth(0)
   , mHeight(0)
+  , mDisplayWidth(0)
+  , mDisplayHeight(0)
   , mSampleFreq(0)
   , mChannels(0)
 {}
 
 } // namespace mozilla
--- a/dom/media/webm/NesteggPacketHolder.h
+++ b/dom/media/webm/NesteggPacketHolder.h
@@ -19,16 +19,17 @@ namespace mozilla {
 class NesteggPacketHolder {
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(NesteggPacketHolder)
   NesteggPacketHolder()
     : mPacket(nullptr)
     , mOffset(-1)
     , mTimestamp(-1)
     , mDuration(-1)
+    , mTrack(0)
     , mIsKeyframe(false) {}
 
   bool Init(nestegg_packet* aPacket, int64_t aOffset, unsigned aTrack, bool aIsKeyframe)
   {
     uint64_t timestamp_ns;
     if (nestegg_packet_tstamp(aPacket, &timestamp_ns) == -1) {
       return false;
     }
--- a/dom/media/webspeech/synth/cocoa/OSXSpeechSynthesizerService.mm
+++ b/dom/media/webspeech/synth/cocoa/OSXSpeechSynthesizerService.mm
@@ -104,16 +104,17 @@ NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTING_ADDREF(SpeechTaskCallback)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(SpeechTaskCallback)
 
 SpeechTaskCallback::SpeechTaskCallback(nsISpeechTask* aTask,
                                        NSSpeechSynthesizer* aSynth,
                                        const nsTArray<size_t>& aOffsets)
   : mTask(aTask)
   , mSpeechSynthesizer(aSynth)
+  , mCurrentIndex(0)
   , mOffsets(aOffsets)
 {
   mDelegate = [[SpeechDelegate alloc] initWithCallback:this];
   [mSpeechSynthesizer setDelegate:mDelegate];
   mStartingTime = TimeStamp::Now();
 }
 
 SpeechTaskCallback::~SpeechTaskCallback()
--- a/dom/media/webspeech/synth/ipc/SpeechSynthesisChild.cpp
+++ b/dom/media/webspeech/synth/ipc/SpeechSynthesisChild.cpp
@@ -157,16 +157,17 @@ SpeechSynthesisRequestChild::RecvOnMark(
   mTask->DispatchMarkImpl(aName, aElapsedTime, aCharIndex);
   return IPC_OK();
 }
 
 // SpeechTaskChild
 
 SpeechTaskChild::SpeechTaskChild(SpeechSynthesisUtterance* aUtterance, bool aIsChrome)
   : nsSpeechTask(aUtterance, aIsChrome)
+  , mActor(nullptr)
 {
 }
 
 NS_IMETHODIMP
 SpeechTaskChild::Setup(nsISpeechTaskCallback* aCallback)
 {
   MOZ_CRASH("Should never be called from child");
 }
--- a/dom/media/webspeech/synth/ipc/SpeechSynthesisParent.h
+++ b/dom/media/webspeech/synth/ipc/SpeechSynthesisParent.h
@@ -75,17 +75,21 @@ protected:
   mozilla::ipc::IPCResult Recv__delete__() override;
 };
 
 class SpeechTaskParent : public nsSpeechTask
 {
   friend class SpeechSynthesisRequestParent;
 public:
   SpeechTaskParent(float aVolume, const nsAString& aUtterance, bool aIsChrome)
-    : nsSpeechTask(aVolume, aUtterance, aIsChrome) {}
+    : nsSpeechTask(aVolume
+    , aUtterance, aIsChrome)
+    , mActor(nullptr)
+    {
+    }
 
   nsresult DispatchStartImpl(const nsAString& aUri) override;
 
   nsresult DispatchEndImpl(float aElapsedTime, uint32_t aCharIndex) override;
 
   nsresult DispatchPauseImpl(float aElapsedTime, uint32_t aCharIndex) override;
 
   nsresult DispatchResumeImpl(float aElapsedTime, uint32_t aCharIndex) override;
--- a/dom/media/webspeech/synth/nsSynthVoiceRegistry.cpp
+++ b/dom/media/webspeech/synth/nsSynthVoiceRegistry.cpp
@@ -113,17 +113,18 @@ private:
 public:
   GlobalQueueItem(VoiceData* aVoice, nsSpeechTask* aTask, const nsAString& aText,
                   const float& aVolume, const float& aRate, const float& aPitch)
     : mVoice(aVoice)
     , mTask(aTask)
     , mText(aText)
     , mVolume(aVolume)
     , mRate(aRate)
-    , mPitch(aPitch) {}
+    , mPitch(aPitch)
+    , mIsLocal(false) {}
 
   NS_INLINE_DECL_REFCOUNTING(GlobalQueueItem)
 
   RefPtr<VoiceData> mVoice;
 
   RefPtr<nsSpeechTask> mTask;
 
   nsString mText;
--- a/layout/reftests/css-grid/reftest.list
+++ b/layout/reftests/css-grid/reftest.list
@@ -140,17 +140,17 @@ skip-if(!gtkWidget) == grid-item-mixed-b
 == grid-align-content-001.html grid-align-content-001-ref.html
 == grid-justify-content-001.html grid-justify-content-001-ref.html
 skip-if(Android&&isDebugBuild) == grid-justify-content-002.html grid-justify-content-002-ref.html # Bug 1245884 - slow
 skip-if(Android&&isDebugBuild) == grid-justify-content-003.html grid-justify-content-003-ref.html # Bug 1245884 - slow
 skip-if(!gtkWidget) == grid-container-baselines-001.html grid-container-baselines-001-ref.html
 skip-if(!gtkWidget) == grid-container-baselines-002.html grid-container-baselines-002-ref.html
 skip-if(!gtkWidget) == grid-container-baselines-003.html grid-container-baselines-003-ref.html
 == grid-container-baselines-004.html grid-container-baselines-004-ref.html
-== grid-container-synthesized-baseline-001-ref.html grid-container-synthesized-baseline-001-ref.html
+== grid-container-synthesized-baseline-001.html grid-container-synthesized-baseline-001-ref.html
 skip-if(Android&&isDebugBuild) == grid-column-gap-001.html grid-column-gap-001-ref.html # Bug 1245884 - slow
 == grid-column-gap-002.html grid-column-gap-002-ref.html
 == grid-column-gap-003.html grid-column-gap-003-ref.html
 == grid-column-gap-004.html grid-column-gap-004-ref.html
 == grid-row-gap-001.html grid-row-gap-001-ref.html
 == grid-percent-grid-gap-001.html grid-percent-grid-gap-001-ref.html
 skip-if(Android&&isDebugBuild) == grid-row-gap-002.html grid-row-gap-002-ref.html # Bug 1245884 - slow
 skip-if(Android&&isDebugBuild) == grid-row-gap-003.html grid-row-gap-003-ref.html # Bug 1245884 - slow
--- a/layout/reftests/text-overflow/reftest.list
+++ b/layout/reftests/text-overflow/reftest.list
@@ -20,17 +20,17 @@ skip-if(Android) fuzzy-if(skiaContent,1,
 == theme-overflow.html theme-overflow-ref.html
 == table-cell.html table-cell-ref.html
 fuzzy-if(gtkWidget,10,32) fuzzy-if(webrender,47,18) == two-value-syntax.html two-value-syntax-ref.html
 == single-value.html single-value-ref.html
 fuzzy-if(gtkWidget,10,2) == atomic-under-marker.html atomic-under-marker-ref.html
 fuzzy(1,2616) skip-if(Android) fuzzy-if(asyncPan&&!layersGPUAccelerated,102,12352) fails-if(gtkWidget) == xulscroll.html xulscroll-ref.html # gtkWidget:bug 1309107, bug 1328771
 == combobox-zoom.html combobox-zoom-ref.html
 == dynamic-change-1.html dynamic-change-1-ref.html
-== float-edges-1-ref.html float-edges-1-ref.html
+== float-edges-1.html float-edges-1-ref.html
 
 # The vertical-text pref setting can be removed after bug 1138384 lands
 == vertical-decorations-1.html vertical-decorations-1-ref.html
 == vertical-decorations-2.html vertical-decorations-2-ref.html
 != vertical-decorations-1.html vertical-decorations-1-2-notref.html
 != vertical-decorations-2.html vertical-decorations-1-2-notref.html
 == vertical-decorations-3.html vertical-decorations-3-ref.html
 == vertical-decorations-4.html vertical-decorations-4-ref.html
--- a/servo/components/malloc_size_of/Cargo.toml
+++ b/servo/components/malloc_size_of/Cargo.toml
@@ -24,17 +24,17 @@ servo = [
 
 [dependencies]
 app_units = "0.6"
 cssparser = "0.23.0"
 euclid = "0.17"
 hashglobe = { path = "../hashglobe" }
 hyper = { version = "0.10", optional = true }
 hyper_serde = { version = "0.8", optional = true }
-mozjs = { version = "0.6", features = ["promises"], optional = true }
+mozjs = { version = "0.7.1", features = ["promises"], optional = true }
 selectors = { path = "../selectors" }
 serde = { version = "1.0.27", optional = true }
 serde_bytes = { version = "0.10", optional = true }
 servo_arc = { path = "../servo_arc" }
 smallbitvec = "2.1.0"
 smallvec = "0.6"
 string_cache = { version = "0.7", optional = true }
 time = { version = "0.1.17", optional = true }
--- a/servo/components/malloc_size_of/lib.rs
+++ b/servo/components/malloc_size_of/lib.rs
@@ -788,17 +788,17 @@ malloc_size_of_is_0!(webrender_api::Filt
 malloc_size_of_is_0!(webrender_api::ExternalScrollId);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::FontInstanceKey);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::GradientStop);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::GlyphInstance);
 #[cfg(feature = "webrender_api")]
-malloc_size_of_is_0!(webrender_api::ImageBorder);
+malloc_size_of_is_0!(webrender_api::NinePatchBorder);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::ImageKey);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::ImageRendering);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::LineStyle);
 #[cfg(feature = "webrender_api")]
 malloc_size_of_is_0!(webrender_api::MixBlendMode);
--- a/servo/components/malloc_size_of_derive/Cargo.toml
+++ b/servo/components/malloc_size_of_derive/Cargo.toml
@@ -5,11 +5,11 @@ authors = ["The Servo Project Developers
 license = "MIT/Apache-2.0"
 publish = false
 
 [lib]
 path = "lib.rs"
 proc-macro = true
 
 [dependencies]
-quote = "0.4.2"
-syn = { version = "0.12.12", features = ["full"] }
-synstructure = "0.7"
+quote = "0.5.1"
+syn = { version = "0.13.1", features = ["full"] }
+synstructure = "0.8"
--- a/servo/components/malloc_size_of_derive/lib.rs
+++ b/servo/components/malloc_size_of_derive/lib.rs
@@ -5,26 +5,20 @@
 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
 //! A crate for deriving the MallocSizeOf trait.
 
-#[macro_use] extern crate quote;
+extern crate quote;
 #[macro_use] extern crate syn;
-
-#[cfg(not(test))]
 #[macro_use] extern crate synstructure;
 
-#[cfg(test)]
-extern crate synstructure;
-
-
 #[cfg(not(test))]
 decl_derive!([MallocSizeOf, attributes(ignore_malloc_size_of)] => malloc_size_of_derive);
 
 fn malloc_size_of_derive(s: synstructure::Structure) -> quote::Tokens {
     let match_body = s.each(|binding| {
         let ignore = binding.ast().attrs.iter().any(|attr| match attr.interpret_meta().unwrap() {
             syn::Meta::Word(ref ident) |
             syn::Meta::List(syn::MetaList { ref ident, .. }) if ident == "ignore_malloc_size_of" => {
deleted file mode 100644
--- a/servo/components/nonzero/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "nonzero"
-version = "0.0.1"
-authors = ["The Servo Project Developers"]
-license = "MPL-2.0"
-publish = false
-
-[lib]
-path = "lib.rs"
-
-[features]
-unstable = ["serde/unstable"]
-
-[dependencies]
-serde = "1.0.14"
deleted file mode 100644
--- a/servo/components/nonzero/lib.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! `NonZero*` types that are either `core::nonzero::NonZero<_>`
-//! or some stable types with an equivalent API (but no memory layout optimization).
-
-#![cfg_attr(feature = "unstable", feature(nonzero))]
-#![cfg_attr(feature = "unstable", feature(const_fn))]
-
-extern crate serde;
-
-use std::fmt;
-
-macro_rules! impl_nonzero_fmt {
-    ( ( $( $Trait: ident ),+ ) for $Ty: ident ) => {
-        $(
-            impl fmt::$Trait for $Ty {
-                #[inline]
-                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                    self.get().fmt(f)
-                }
-            }
-        )+
-    }
-}
-
-macro_rules! nonzero_integers {
-    ( $( $Ty: ident($Int: ty); )+ ) => {
-        $(
-            #[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
-            pub struct $Ty(
-                #[cfg(feature = "unstable")] std::num::$Ty,
-                #[cfg(not(feature = "unstable"))] $Int,
-            );
-
-            impl $Ty {
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub const unsafe fn new_unchecked(n: $Int) -> Self {
-                    $Ty(std::num::$Ty::new_unchecked(n))
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub unsafe fn new_unchecked(n: $Int) -> Self {
-                    $Ty(n)
-                }
-
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub fn new(n: $Int) -> Option<Self> {
-                    std::num::$Ty::new(n).map($Ty)
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub fn new(n: $Int) -> Option<Self> {
-                    if n != 0 {
-                        Some($Ty(n))
-                    } else {
-                        None
-                    }
-                }
-
-                #[cfg(feature = "unstable")]
-                #[inline]
-                pub fn get(self) -> $Int {
-                    self.0.get()
-                }
-
-                #[cfg(not(feature = "unstable"))]
-                #[inline]
-                pub fn get(self) -> $Int {
-                    self.0
-                }
-            }
-
-            impl_nonzero_fmt! {
-                (Debug, Display, Binary, Octal, LowerHex, UpperHex) for $Ty
-            }
-
-            impl serde::Serialize for $Ty {
-                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-                    where S: serde::Serializer
-                {
-                    self.get().serialize(serializer)
-                }
-            }
-
-            impl<'de> serde::Deserialize<'de> for $Ty {
-                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                    where D: serde::Deserializer<'de>
-                {
-                    let value = <$Int>::deserialize(deserializer)?;
-                    match <$Ty>::new(value) {
-                        Some(nonzero) => Ok(nonzero),
-                        None => Err(serde::de::Error::custom("expected a non-zero value")),
-                    }
-                }
-            }
-        )+
-    }
-}
-
-nonzero_integers! {
-    NonZeroU8(u8);
-    NonZeroU16(u16);
-    NonZeroU32(u32);
-    NonZeroU64(u64);
-    NonZeroUsize(usize);
-}
deleted file mode 100644
--- a/servo/components/servo/Cargo.toml
+++ /dev/null
@@ -1,67 +0,0 @@
-[package]
-
-name = "libservo"
-version = "0.0.1"
-authors = ["The Servo Project Developers"]
-license = "MPL-2.0"
-publish = false
-
-[lib]
-name = "servo"
-path = "lib.rs"
-crate-type = ["rlib"]
-
-[features]
-max_log_level = ["log/release_max_level_info"]
-webdriver = ["webdriver_server"]
-energy-profiling = ["profile_traits/energy-profiling"]
-debugmozjs = ["script/debugmozjs"]
-googlevr = ["webvr/googlevr"]
-webrender_debugger = ["webrender/debugger"]
-oculusvr = ["webvr/oculusvr"]
-unstable = [
-    "euclid/unstable",
-    "gfx/unstable",
-    "msg/unstable",
-    "profile/unstable",
-    "script/unstable",
-]
-
-[dependencies]
-bluetooth_traits = {path = "../bluetooth_traits"}
-bluetooth = {path = "../bluetooth"}
-canvas = {path = "../canvas"}
-canvas_traits = {path = "../canvas_traits"}
-compositing = {path = "../compositing"}
-constellation = {path = "../constellation"}
-debugger = {path = "../debugger"}
-devtools = {path = "../devtools"}
-devtools_traits = {path = "../devtools_traits"}
-env_logger = "0.5"
-euclid = "0.17"
-gfx = {path = "../gfx"}
-gleam = "0.4.29"
-ipc-channel = "0.10"
-layout_thread = {path = "../layout_thread"}
-log = "0.4"
-msg = {path = "../msg"}
-net = {path = "../net"}
-net_traits = {path = "../net_traits"}
-profile = {path = "../profile"}
-profile_traits = {path = "../profile_traits"}
-script = {path = "../script"}
-script_layout_interface = {path = "../script_layout_interface"}
-script_traits = {path = "../script_traits"}
-servo_config = {path = "../config"}
-servo_geometry = {path = "../geometry"}
-servo_url = {path = "../url"}
-style = {path = "../style", features = ["servo"]}
-style_traits = {path = "../style_traits", features = ["servo"]}
-webrender = {git = "https://github.com/servo/webrender"}
-webrender_api = {git = "https://github.com/servo/webrender", features = ["ipc"]}
-webdriver_server = {path = "../webdriver_server", optional = true}
-webvr = {path = "../webvr"}
-webvr_traits = {path = "../webvr_traits"}
-
-[target.'cfg(all(not(target_os = "windows"), not(target_os = "ios")))'.dependencies]
-gaol = {git = "https://github.com/servo/gaol"}
deleted file mode 100644
--- a/servo/components/servo/lib.rs
+++ /dev/null
@@ -1,617 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
-
-//! Servo, the mighty web browser engine from the future.
-//!
-//! This is a very simple library that wires all of Servo's components
-//! together as type `Servo`, along with a generic client
-//! implementing the `WindowMethods` trait, to create a working web
-//! browser.
-//!
-//! The `Servo` type is responsible for configuring a
-//! `Constellation`, which does the heavy lifting of coordinating all
-//! of Servo's internal subsystems, including the `ScriptThread` and the
-//! `LayoutThread`, as well maintains the navigation context.
-//!
-//! `Servo` is fed events from a generic type that implements the
-//! `WindowMethods` trait.
-
-extern crate env_logger;
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-extern crate gaol;
-extern crate gleam;
-#[macro_use]
-extern crate log;
-
-pub extern crate bluetooth;
-pub extern crate bluetooth_traits;
-pub extern crate canvas;
-pub extern crate canvas_traits;
-pub extern crate compositing;
-pub extern crate constellation;
-pub extern crate debugger;
-pub extern crate devtools;
-pub extern crate devtools_traits;
-pub extern crate euclid;
-pub extern crate gfx;
-pub extern crate ipc_channel;
-pub extern crate layout_thread;
-pub extern crate msg;
-pub extern crate net;
-pub extern crate net_traits;
-pub extern crate profile;
-pub extern crate profile_traits;
-pub extern crate script;
-pub extern crate script_traits;
-pub extern crate script_layout_interface;
-pub extern crate servo_config;
-pub extern crate servo_geometry;
-pub extern crate servo_url;
-pub extern crate style;
-pub extern crate style_traits;
-pub extern crate webrender_api;
-pub extern crate webvr;
-pub extern crate webvr_traits;
-
-#[cfg(feature = "webdriver")]
-extern crate webdriver_server;
-
-extern crate webrender;
-
-#[cfg(feature = "webdriver")]
-fn webdriver(port: u16, constellation: Sender<ConstellationMsg>) {
-    webdriver_server::start_server(port, constellation);
-}
-
-#[cfg(not(feature = "webdriver"))]
-fn webdriver(_port: u16, _constellation: Sender<ConstellationMsg>) { }
-
-use bluetooth::BluetoothThreadFactory;
-use bluetooth_traits::BluetoothRequest;
-use canvas::gl_context::GLContextFactory;
-use canvas::webgl_thread::WebGLThreads;
-use compositing::{IOCompositor, ShutdownState, RenderNotifier};
-use compositing::compositor_thread::{self, CompositorProxy, CompositorReceiver, InitialCompositorState};
-use compositing::compositor_thread::{EmbedderMsg, EmbedderProxy, EmbedderReceiver};
-use compositing::windowing::{WindowEvent, WindowMethods};
-use constellation::{Constellation, InitialConstellationState, UnprivilegedPipelineContent};
-use constellation::{FromCompositorLogger, FromScriptLogger};
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-use constellation::content_process_sandbox_profile;
-use env_logger::Builder as EnvLoggerBuilder;
-use euclid::Length;
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-use gaol::sandbox::{ChildSandbox, ChildSandboxMethods};
-use gfx::font_cache_thread::FontCacheThread;
-use ipc_channel::ipc::{self, IpcSender};
-use log::{Log, Metadata, Record};
-use net::resource_thread::new_resource_threads;
-use net_traits::IpcSend;
-use profile::mem as profile_mem;
-use profile::time as profile_time;
-use profile_traits::mem;
-use profile_traits::time;
-use script_traits::{ConstellationMsg, SWManagerSenders, ScriptToConstellationChan};
-use servo_config::opts;
-use servo_config::prefs::PREFS;
-use servo_config::resource_files::resources_dir_path;
-use std::borrow::Cow;
-use std::cmp::max;
-use std::path::PathBuf;
-use std::rc::Rc;
-use std::sync::mpsc::{Sender, channel};
-use webrender::RendererKind;
-use webvr::{WebVRThread, WebVRCompositorHandler};
-
-pub use gleam::gl;
-pub use servo_config as config;
-pub use servo_url as url;
-pub use msg::constellation_msg::{KeyState, TopLevelBrowsingContextId as BrowserId};
-
-/// The in-process interface to Servo.
-///
-/// It does everything necessary to render the web, primarily
-/// orchestrating the interaction between JavaScript, CSS layout,
-/// rendering, and the client window.
-///
-/// Clients create a `Servo` instance for a given reference-counted type
-/// implementing `WindowMethods`, which is the bridge to whatever
-/// application Servo is embedded in. Clients then create an event
-/// loop to pump messages between the embedding application and
-/// various browser components.
-pub struct Servo<Window: WindowMethods + 'static> {
-    compositor: IOCompositor<Window>,
-    constellation_chan: Sender<ConstellationMsg>,
-    embedder_receiver: EmbedderReceiver,
-    embedder_events: Vec<EmbedderMsg>,
-}
-
-impl<Window> Servo<Window> where Window: WindowMethods + 'static {
-    pub fn new(window: Rc<Window>) -> Servo<Window> {
-        // Global configuration options, parsed from the command line.
-        let opts = opts::get();
-
-        // Make sure the gl context is made current.
-        window.prepare_for_composite(Length::new(0), Length::new(0));
-
-        // Get both endpoints of a special channel for communication between
-        // the client window and the compositor. This channel is unique because
-        // messages to client may need to pump a platform-specific event loop
-        // to deliver the message.
-        let (compositor_proxy, compositor_receiver) =
-            create_compositor_channel(window.create_event_loop_waker());
-        let (embedder_proxy, embedder_receiver) =
-            create_embedder_channel(window.create_event_loop_waker());
-        let supports_clipboard = window.supports_clipboard();
-        let time_profiler_chan = profile_time::Profiler::create(&opts.time_profiling,
-                                                                opts.time_profiler_trace_path.clone());
-        let mem_profiler_chan = profile_mem::Profiler::create(opts.mem_profiler_period);
-        let debugger_chan = opts.debugger_port.map(|port| {
-            debugger::start_server(port)
-        });
-        let devtools_chan = opts.devtools_port.map(|port| {
-            devtools::start_server(port)
-        });
-
-        let mut resource_path = resources_dir_path().unwrap();
-        resource_path.push("shaders");
-
-        let coordinates = window.get_coordinates();
-
-        let (mut webrender, webrender_api_sender) = {
-            let renderer_kind = if opts::get().should_use_osmesa() {
-                RendererKind::OSMesa
-            } else {
-                RendererKind::Native
-            };
-
-            let recorder = if opts.webrender_record {
-                let record_path = PathBuf::from("wr-record.bin");
-                let recorder = Box::new(webrender::BinaryRecorder::new(&record_path));
-                Some(recorder as Box<webrender::ApiRecordingReceiver>)
-            } else {
-                None
-            };
-
-            let mut debug_flags = webrender::DebugFlags::empty();
-            debug_flags.set(webrender::DebugFlags::PROFILER_DBG, opts.webrender_stats);
-
-            let render_notifier = Box::new(RenderNotifier::new(compositor_proxy.clone()));
-
-            webrender::Renderer::new(window.gl(), render_notifier, webrender::RendererOptions {
-                device_pixel_ratio: coordinates.hidpi_factor.get(),
-                resource_override_path: Some(resource_path),
-                enable_aa: opts.enable_text_antialiasing,
-                debug_flags: debug_flags,
-                recorder: recorder,
-                precache_shaders: opts.precache_shaders,
-                enable_scrollbars: opts.output_file.is_none(),
-                renderer_kind: renderer_kind,
-                enable_subpixel_aa: opts.enable_subpixel_text_antialiasing,
-                ..Default::default()
-            }).expect("Unable to initialize webrender!")
-        };
-
-        let webrender_api = webrender_api_sender.create_api();
-        let wr_document_layer = 0; //TODO
-        let webrender_document = webrender_api.add_document(coordinates.framebuffer, wr_document_layer);
-
-        // Important that this call is done in a single-threaded fashion, we
-        // can't defer it after `create_constellation` has started.
-        script::init();
-
-        // Create the constellation, which maintains the engine
-        // pipelines, including the script and layout threads, as well
-        // as the navigation context.
-        let (constellation_chan, sw_senders) = create_constellation(opts.user_agent.clone(),
-                                                                    opts.config_dir.clone(),
-                                                                    embedder_proxy.clone(),
-                                                                    compositor_proxy.clone(),
-                                                                    time_profiler_chan.clone(),
-                                                                    mem_profiler_chan.clone(),
-                                                                    debugger_chan,
-                                                                    devtools_chan,
-                                                                    supports_clipboard,
-                                                                    &mut webrender,
-                                                                    webrender_document,
-                                                                    webrender_api_sender,
-                                                                    window.gl());
-
-        // Send the constellation's swmanager sender to service worker manager thread
-        script::init_service_workers(sw_senders);
-
-        if cfg!(feature = "webdriver") {
-            if let Some(port) = opts.webdriver_port {
-                webdriver(port, constellation_chan.clone());
-            }
-        }
-
-        // The compositor coordinates with the client window to create the final
-        // rendered page and display it somewhere.
-        let compositor = IOCompositor::create(window, InitialCompositorState {
-            sender: compositor_proxy,
-            receiver: compositor_receiver,
-            constellation_chan: constellation_chan.clone(),
-            time_profiler_chan: time_profiler_chan,
-            mem_profiler_chan: mem_profiler_chan,
-            webrender,
-            webrender_document,
-            webrender_api,
-        });
-
-        Servo {
-            compositor: compositor,
-            constellation_chan: constellation_chan,
-            embedder_receiver: embedder_receiver,
-            embedder_events: Vec::new(),
-        }
-    }
-
-    fn handle_window_event(&mut self, event: WindowEvent) {
-        match event {
-            WindowEvent::Idle => {
-            }
-
-            WindowEvent::Refresh => {
-                self.compositor.composite();
-            }
-
-            WindowEvent::Resize => {
-                self.compositor.on_resize_window_event();
-            }
-
-            WindowEvent::LoadUrl(top_level_browsing_context_id, url) => {
-                let msg = ConstellationMsg::LoadUrl(top_level_browsing_context_id, url);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending load url to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::MouseWindowEventClass(mouse_window_event) => {
-                self.compositor.on_mouse_window_event_class(mouse_window_event);
-            }
-
-            WindowEvent::MouseWindowMoveEventClass(cursor) => {
-                self.compositor.on_mouse_window_move_event_class(cursor);
-            }
-
-            WindowEvent::Touch(event_type, identifier, location) => {
-                self.compositor.on_touch_event(event_type, identifier, location);
-            }
-
-            WindowEvent::Scroll(delta, cursor, phase) => {
-                self.compositor.on_scroll_event(delta, cursor, phase);
-            }
-
-            WindowEvent::Zoom(magnification) => {
-                self.compositor.on_zoom_window_event(magnification);
-            }
-
-            WindowEvent::ResetZoom => {
-                self.compositor.on_zoom_reset_window_event();
-            }
-
-            WindowEvent::PinchZoom(magnification) => {
-                self.compositor.on_pinch_zoom_window_event(magnification);
-            }
-
-            WindowEvent::Navigation(top_level_browsing_context_id, direction) => {
-                let msg = ConstellationMsg::TraverseHistory(top_level_browsing_context_id, direction);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending navigation to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::KeyEvent(ch, key, state, modifiers) => {
-                let msg = ConstellationMsg::KeyEvent(ch, key, state, modifiers);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending key event to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::Quit => {
-                self.compositor.maybe_start_shutting_down();
-            }
-
-            WindowEvent::Reload(top_level_browsing_context_id) => {
-                let msg = ConstellationMsg::Reload(top_level_browsing_context_id);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending reload to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::ToggleWebRenderDebug(option) => {
-                self.compositor.toggle_webrender_debug(option);
-            }
-
-            WindowEvent::CaptureWebRender => {
-                self.compositor.capture_webrender();
-            }
-
-            WindowEvent::NewBrowser(url, response_chan) => {
-                let msg = ConstellationMsg::NewBrowser(url, response_chan);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending NewBrowser message to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::SelectBrowser(ctx) => {
-                let msg = ConstellationMsg::SelectBrowser(ctx);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending SelectBrowser message to constellation failed ({}).", e);
-                }
-            }
-
-            WindowEvent::CloseBrowser(ctx) => {
-                let msg = ConstellationMsg::CloseBrowser(ctx);
-                if let Err(e) = self.constellation_chan.send(msg) {
-                    warn!("Sending CloseBrowser message to constellation failed ({}).", e);
-                }
-            }
-        }
-    }
-
-    fn receive_messages(&mut self) {
-        while let Some(msg) = self.embedder_receiver.try_recv_embedder_msg() {
-            match (msg, self.compositor.shutdown_state) {
-                (_, ShutdownState::FinishedShuttingDown) => {
-                    error!("embedder shouldn't be handling messages after compositor has shut down");
-                },
-
-                (_, ShutdownState::ShuttingDown) => {},
-
-                (EmbedderMsg::KeyEvent(top_level_browsing_context, ch, key, state, modified),
-                 ShutdownState::NotShuttingDown) => {
-                    if state == KeyState::Pressed {
-                        let msg = EmbedderMsg::KeyEvent(top_level_browsing_context, ch, key, state, modified);
-                        self.embedder_events.push(msg);
-                    }
-                },
-
-                (msg, ShutdownState::NotShuttingDown) => {
-                    self.embedder_events.push(msg);
-                },
-            }
-        }
-    }
-
-    pub fn get_events(&mut self) -> Vec<EmbedderMsg> {
-        ::std::mem::replace(&mut self.embedder_events, Vec::new())
-    }
-
-    pub fn handle_events(&mut self, events: Vec<WindowEvent>) {
-        if self.compositor.receive_messages() {
-            self.receive_messages();
-        }
-        for event in events {
-            self.handle_window_event(event);
-        }
-        if self.compositor.shutdown_state != ShutdownState::FinishedShuttingDown {
-            self.compositor.perform_updates();
-        } else {
-            self.embedder_events.push(EmbedderMsg::Shutdown);
-        }
-    }
-
-    pub fn repaint_synchronously(&mut self) {
-        self.compositor.repaint_synchronously()
-    }
-
-    pub fn pinch_zoom_level(&self) -> f32 {
-        self.compositor.pinch_zoom_level()
-    }
-
-    pub fn setup_logging(&self) {
-        let constellation_chan = self.constellation_chan.clone();
-        let env = env_logger::Env::default();
-        let env_logger = EnvLoggerBuilder::from_env(env).build();
-        let con_logger = FromCompositorLogger::new(constellation_chan);
-
-        let filter = max(env_logger.filter(), con_logger.filter());
-        let logger = BothLogger(env_logger, con_logger);
-
-        log::set_boxed_logger(Box::new(logger)).expect("Failed to set logger.");
-        log::set_max_level(filter);
-    }
-
-    pub fn deinit(self) {
-        self.compositor.deinit();
-    }
-}
-
-fn create_embedder_channel(event_loop_waker: Box<compositor_thread::EventLoopWaker>)
-    -> (EmbedderProxy, EmbedderReceiver) {
-    let (sender, receiver) = channel();
-    (EmbedderProxy {
-         sender: sender,
-         event_loop_waker: event_loop_waker,
-     },
-     EmbedderReceiver {
-         receiver: receiver
-     })
-}
-
-fn create_compositor_channel(event_loop_waker: Box<compositor_thread::EventLoopWaker>)
-    -> (CompositorProxy, CompositorReceiver) {
-    let (sender, receiver) = channel();
-    (CompositorProxy {
-         sender: sender,
-         event_loop_waker: event_loop_waker,
-     },
-     CompositorReceiver {
-         receiver: receiver
-     })
-}
-
-fn create_constellation(user_agent: Cow<'static, str>,
-                        config_dir: Option<PathBuf>,
-                        embedder_proxy: EmbedderProxy,
-                        compositor_proxy: CompositorProxy,
-                        time_profiler_chan: time::ProfilerChan,
-                        mem_profiler_chan: mem::ProfilerChan,
-                        debugger_chan: Option<debugger::Sender>,
-                        devtools_chan: Option<Sender<devtools_traits::DevtoolsControlMsg>>,
-                        supports_clipboard: bool,
-                        webrender: &mut webrender::Renderer,
-                        webrender_document: webrender_api::DocumentId,
-                        webrender_api_sender: webrender_api::RenderApiSender,
-                        window_gl: Rc<gl::Gl>)
-                        -> (Sender<ConstellationMsg>, SWManagerSenders) {
-    let bluetooth_thread: IpcSender<BluetoothRequest> = BluetoothThreadFactory::new();
-
-    let (public_resource_threads, private_resource_threads) =
-        new_resource_threads(user_agent,
-                             devtools_chan.clone(),
-                             time_profiler_chan.clone(),
-                             mem_profiler_chan.clone(),
-                             config_dir);
-    let font_cache_thread = FontCacheThread::new(public_resource_threads.sender(),
-                                                 webrender_api_sender.create_api());
-
-    let resource_sender = public_resource_threads.sender();
-
-    let (webvr_chan, webvr_constellation_sender, webvr_compositor) = if PREFS.is_webvr_enabled() {
-        // WebVR initialization
-        let (mut handler, sender) = WebVRCompositorHandler::new();
-        let (webvr_thread, constellation_sender) = WebVRThread::spawn(sender);
-        handler.set_webvr_thread_sender(webvr_thread.clone());
-        (Some(webvr_thread), Some(constellation_sender), Some(handler))
-    } else {
-        (None, None, None)
-    };
-
-    // GLContext factory used to create WebGL Contexts
-    let gl_factory = if opts::get().should_use_osmesa() {
-        GLContextFactory::current_osmesa_handle()
-    } else {
-        GLContextFactory::current_native_handle(&compositor_proxy)
-    };
-
-    // Initialize WebGL Thread entry point.
-    let webgl_threads = gl_factory.map(|factory| {
-        let (webgl_threads, image_handler, output_handler) =
-            WebGLThreads::new(
-                factory,
-                window_gl,
-                webrender_api_sender.clone(),
-                webvr_compositor.map(|c| c as Box<_>),
-            );
-
-        // Set webrender external image handler for WebGL textures
-        webrender.set_external_image_handler(image_handler);
-
-        // Set DOM to texture handler, if enabled.
-        if let Some(output_handler) = output_handler {
-            webrender.set_output_image_handler(output_handler);
-        }
-
-        webgl_threads
-    });
-
-    let initial_state = InitialConstellationState {
-        compositor_proxy,
-        embedder_proxy,
-        debugger_chan,
-        devtools_chan,
-        bluetooth_thread,
-        font_cache_thread,
-        public_resource_threads,
-        private_resource_threads,
-        time_profiler_chan,
-        mem_profiler_chan,
-        supports_clipboard,
-        webrender_document,
-        webrender_api_sender,
-        webgl_threads,
-        webvr_chan,
-    };
-    let (constellation_chan, from_swmanager_sender) =
-        Constellation::<script_layout_interface::message::Msg,
-                        layout_thread::LayoutThread,
-                        script::script_thread::ScriptThread>::start(initial_state);
-
-    if let Some(webvr_constellation_sender) = webvr_constellation_sender {
-        // Set constellation channel used by WebVR thread to broadcast events
-        webvr_constellation_sender.send(constellation_chan.clone()).unwrap();
-    }
-
-    // channels to communicate with Service Worker Manager
-    let sw_senders = SWManagerSenders {
-        swmanager_sender: from_swmanager_sender,
-        resource_sender: resource_sender
-    };
-
-    (constellation_chan, sw_senders)
-}
-
-// A logger that logs to two downstream loggers.
-// This should probably be in the log crate.
-struct BothLogger<Log1, Log2>(Log1, Log2);
-
-impl<Log1, Log2> Log for BothLogger<Log1, Log2> where Log1: Log, Log2: Log {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        self.0.enabled(metadata) || self.1.enabled(metadata)
-    }
-
-    fn log(&self, record: &Record) {
-        self.0.log(record);
-        self.1.log(record);
-    }
-
-    fn flush(&self) {
-        self.0.flush();
-        self.1.flush();
-    }
-}
-
-pub fn set_logger(script_to_constellation_chan: ScriptToConstellationChan) {
-    let con_logger = FromScriptLogger::new(script_to_constellation_chan);
-    let env = env_logger::Env::default();
-    let env_logger = EnvLoggerBuilder::from_env(env).build();
-
-    let filter = max(env_logger.filter(), con_logger.filter());
-    let logger = BothLogger(env_logger, con_logger);
-
-    log::set_boxed_logger(Box::new(logger)).expect("Failed to set logger.");
-    log::set_max_level(filter);
-}
-
-/// Content process entry point.
-pub fn run_content_process(token: String) {
-    let (unprivileged_content_sender, unprivileged_content_receiver) =
-        ipc::channel::<UnprivilegedPipelineContent>().unwrap();
-    let connection_bootstrap: IpcSender<IpcSender<UnprivilegedPipelineContent>> =
-        IpcSender::connect(token).unwrap();
-    connection_bootstrap.send(unprivileged_content_sender).unwrap();
-
-    let unprivileged_content = unprivileged_content_receiver.recv().unwrap();
-    opts::set_defaults(unprivileged_content.opts());
-    PREFS.extend(unprivileged_content.prefs());
-    set_logger(unprivileged_content.script_to_constellation_chan().clone());
-
-    // Enter the sandbox if necessary.
-    if opts::get().sandbox {
-       create_sandbox();
-    }
-
-    // send the required channels to the service worker manager
-    let sw_senders = unprivileged_content.swmanager_senders();
-    script::init();
-    script::init_service_workers(sw_senders);
-
-    unprivileged_content.start_all::<script_layout_interface::message::Msg,
-                                     layout_thread::LayoutThread,
-                                     script::script_thread::ScriptThread>(true);
-}
-
-#[cfg(all(not(target_os = "windows"), not(target_os = "ios")))]
-fn create_sandbox() {
-    ChildSandbox::new(content_process_sandbox_profile()).activate()
-        .expect("Failed to activate sandbox!");
-}
-
-#[cfg(any(target_os = "windows", target_os = "ios"))]
-fn create_sandbox() {
-    panic!("Sandboxing is not supported on Windows or iOS.");
-}
--- a/servo/components/style_derive/Cargo.toml
+++ b/servo/components/style_derive/Cargo.toml
@@ -5,12 +5,12 @@ authors = ["The Servo Project Developers
 license = "MPL-2.0"
 publish = false
 
 [lib]
 path = "lib.rs"
 proc-macro = true
 
 [dependencies]
-darling = "0.3"
-quote = "0.4.2"
-syn = { version = "0.12.12", features = ["visit"] }
-synstructure = "0.7"
+darling = "0.4"
+quote = "0.5.1"
+syn = { version = "0.13.1", features = ["visit"] }
+synstructure = "0.8"
--- a/third_party/rust/cstr-macros/.cargo-checksum.json
+++ b/third_party/rust/cstr-macros/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"e173ef38709c8afee2488a6b0acf94c7695c3cebe89b3fe444253808bede8405","LICENSE":"2c6fc9268c3b765da5bf34fe4909425437f61be05674c2516c7f8cf1251c20aa","src/lib.rs":"71e7248b21b5e603e31060ecf241cf204efdfea5a0b400d084601f6c8bdfe11c"},"package":"f9f316203d1ea36f4f18316822806f6999aa3dc5ed1adf51e35b77e3b3933d78"}
\ No newline at end of file
+{"files":{"Cargo.toml":"517c9ae719b876cf67d9bd8dfec71d0b7a35ffe6e68668c35e21e2f6c3dfdc05","LICENSE":"2c6fc9268c3b765da5bf34fe4909425437f61be05674c2516c7f8cf1251c20aa","src/lib.rs":"71e7248b21b5e603e31060ecf241cf204efdfea5a0b400d084601f6c8bdfe11c"},"package":"0472c17c83d3ec1af32fb6ee2b3ad56ae0b6e69355d63d1d30602055c34324a8"}
\ No newline at end of file
--- a/third_party/rust/cstr-macros/Cargo.toml
+++ b/third_party/rust/cstr-macros/Cargo.toml
@@ -7,25 +7,25 @@
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
 # editing this file be aware that the upstream Cargo.toml
 # will likely look very different (and much more reasonable)
 
 [package]
 name = "cstr-macros"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Xidorn Quan <me@upsuper.org>"]
 description = "Procedural macros for cstr"
 license = "MIT"
 repository = "https://github.com/upsuper/cstr"
 
 [lib]
 proc-macro = true
 [dependencies.procedural-masquerade]
 version = "0.1"
 
 [dependencies.syn]
-version = "0.12"
+version = "0.13"
 features = ["derive", "parsing"]
 default-features = false
 [dev-dependencies.quote]
-version = "0.4"
+version = "0.5"
--- a/third_party/rust/darling/.cargo-checksum.json
+++ b/third_party/rust/darling/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".travis.yml":"2e3d3211e52ff52d83a0a2a495a28175dbcf2a30ab680d7c8f20622751b04f78","CHANGELOG.md":"fa0ef2d2b2d5382962d371a68e5eba052f5b303d70090e21c2d1f4c5e52b9851","Cargo.toml":"ee3bb349f21a8bf3801692a0af134b3e1071f86bd1d4aa52b47f45c7e9d696eb","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","README.md":"7e05868f02bae698ee3193b86e86f25faa4dbc63661062e1d3f7bff590cfb313","examples/consume_fields.rs":"f32d3873b61e22b1ded500571ec7120420b4825ee7f807d07409e3a257407add","examples/fallible_read.rs":"4e2d558f8a77c4fffa79bde5a6c48df3dbc932822e7bc7cf0a903d1ea38b8d6f","publish.sh":"42795a155247c69402f8c4c917c9874a06dfde5a7606c8b59fc4e9ccd34233dd","src/lib.rs":"c13e19cd0363784d9ec3605bafcaf74648594fb419162143c4ecc3308a8ec695","tests/accrue_errors.rs":"7a995118cfa75ac90accf9a35e17b07a00e8528c8ccc5dd8700ba7b4c59393c1","tests/custom_bound.rs":"cca7c557ac0a2efd9554d31f0df9a98c4f6f01b9f211107846732cc1fe9f7856","tests/enums_newtype.rs":"328ebbbb4aa540f06f13158dff22cf9d98d45dba2331f75e4aa169d348397b76","tests/enums_struct.rs":"560a8bfdea9eca7f8c2024bc8740e71ef1a0681cea36b098ceadba520fad8640","tests/enums_unit.rs":"5e9458af9d695706e181b6622dcbc8b80b9eae33dcc1f15da7eecfd3e7037777","tests/error.rs":"69d12e969555fc1d72990d7596b54adcb469da95f1f257d0273f31bc9c855db5","tests/from_variant.rs":"af60c9dec64e80e2ac3beafb942d8edc1100a1342bb97378e6a35f878dd1fb50","tests/generics.rs":"3d884d65cb6b57d4bc4b3f7c39f321b2df3cd339fa15db5b66dc7c97ef84df17","tests/happy_path.rs":"5143dbf33b59fcab94be61affefddf485857f1a5cb3d45d5583463423d417cdf","tests/multiple.rs":"20e1c5110449db46df68c5a4cdb6e0c4c0e9a6b47451fe73f1523a1cf730196d","tests/newtype.rs":"a8709857e2067bc01b388a11230db5764c9e5fe2341c98d6c819adc01472b988","tests/skip.rs":"e34034c6b5fae80c8cf2caa762a41ab3d971f8af50f1022e68ba299218477892","tests/split_declaration.rs":"d55219ec0dce001ccd1975f0b4fbe0f5e8c5792a1ddf2de5a210d380bc6761e0","tests/supports.rs":"1131c2afd42e20e4a39f922758cbb8d7c5a0167ae41f9cd1cd14b40db055cd10"},"package":"d3effd06d4057f275cb7858889f4952920bab78dd8ff0f6e7dfe0c8d2e67ed89"}
\ No newline at end of file
+{"files":{".travis.yml":"2e3d3211e52ff52d83a0a2a495a28175dbcf2a30ab680d7c8f20622751b04f78","CHANGELOG.md":"d7322023ffc58d041c542f8de0f43167f34ba4fdacc9a5014308d97055f7b729","Cargo.toml":"c1d8f7f99c24eb373e5aefaf3c678eea57d72552fdbb3547872b62b0d28aa07f","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","README.md":"7e05868f02bae698ee3193b86e86f25faa4dbc63661062e1d3f7bff590cfb313","examples/consume_fields.rs":"f32d3873b61e22b1ded500571ec7120420b4825ee7f807d07409e3a257407add","examples/fallible_read.rs":"4e2d558f8a77c4fffa79bde5a6c48df3dbc932822e7bc7cf0a903d1ea38b8d6f","publish.sh":"42795a155247c69402f8c4c917c9874a06dfde5a7606c8b59fc4e9ccd34233dd","src/lib.rs":"c13e19cd0363784d9ec3605bafcaf74648594fb419162143c4ecc3308a8ec695","tests/accrue_errors.rs":"7a995118cfa75ac90accf9a35e17b07a00e8528c8ccc5dd8700ba7b4c59393c1","tests/custom_bound.rs":"cca7c557ac0a2efd9554d31f0df9a98c4f6f01b9f211107846732cc1fe9f7856","tests/enums_newtype.rs":"328ebbbb4aa540f06f13158dff22cf9d98d45dba2331f75e4aa169d348397b76","tests/enums_struct.rs":"560a8bfdea9eca7f8c2024bc8740e71ef1a0681cea36b098ceadba520fad8640","tests/enums_unit.rs":"5e9458af9d695706e181b6622dcbc8b80b9eae33dcc1f15da7eecfd3e7037777","tests/error.rs":"69d12e969555fc1d72990d7596b54adcb469da95f1f257d0273f31bc9c855db5","tests/from_variant.rs":"af60c9dec64e80e2ac3beafb942d8edc1100a1342bb97378e6a35f878dd1fb50","tests/generics.rs":"3d884d65cb6b57d4bc4b3f7c39f321b2df3cd339fa15db5b66dc7c97ef84df17","tests/happy_path.rs":"5143dbf33b59fcab94be61affefddf485857f1a5cb3d45d5583463423d417cdf","tests/multiple.rs":"20e1c5110449db46df68c5a4cdb6e0c4c0e9a6b47451fe73f1523a1cf730196d","tests/newtype.rs":"a8709857e2067bc01b388a11230db5764c9e5fe2341c98d6c819adc01472b988","tests/skip.rs":"e34034c6b5fae80c8cf2caa762a41ab3d971f8af50f1022e68ba299218477892","tests/split_declaration.rs":"d55219ec0dce001ccd1975f0b4fbe0f5e8c5792a1ddf2de5a210d380bc6761e0","tests/supports.rs":"1131c2afd42e20e4a39f922758cbb8d7c5a0167ae41f9cd1cd14b40db055cd10"},"package":"2a78af487e4eb8f4421a1770687b328af6bb4494ca93435210678c6eea875c11"}
\ No newline at end of file
--- a/third_party/rust/darling/CHANGELOG.md
+++ b/third_party/rust/darling/CHANGELOG.md
@@ -1,11 +1,24 @@
 # Changelog
 
-## Unreleased Changes
+## Unreleased Features
+_None_
+
+## v0.4.0 (April 5, 2018)
+- Update dependencies on `proc-macro`, `quote`, and `syn` [#26](https://github.com/TedDriggs/darling/pull/26). Thanks to @hcpl
+
+## v0.3.3 (April 2, 2018)
+**YANKED**
+
+## v0.3.2 (March 13, 2018)
+- Derive `Default` on `darling::Ignored` (fixes [#25](https://github.com/TedDriggs/darling/issues/25)).
+
+## v0.3.1 (March 7, 2018)
+- Support proc-macro2/nightly [#24](https://github.com/TedDriggs/darling/pull/24). Thanks to @kdy1
 
 ## v0.3.0 (January 26, 2018)
 
 ### Breaking Changes
 - Update `syn` to 0.12 [#20](https://github.com/TedDriggs/darling/pull/20). Thanks to @Eijebong
 - Update `quote` to 0.4 [#20](https://github.com/TedDriggs/darling/pull/20). Thanks to @Eijebong
 - Rename magic field `body` in derived `FromDeriveInput` structs to `data` to stay in sync with `syn`
 - Rename magic field `data` in derived `FromVariant` structs to `fields` to stay in sync with `syn`
--- a/third_party/rust/darling/Cargo.toml
+++ b/third_party/rust/darling/Cargo.toml
@@ -7,27 +7,27 @@
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
 # editing this file be aware that the upstream Cargo.toml
 # will likely look very different (and much more reasonable)
 
 [package]
 name = "darling"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
 description = "A proc-macro library for reading attributes into structs when\nimplementing custom derives.\n"
-documentation = "https://docs.rs/darling/0.3.0"
+documentation = "https://docs.rs/darling/0.4.0"
 readme = "README.md"
 license = "MIT"
 repository = "https://github.com/TedDriggs/darling"
 [dependencies.darling_core]
-version = "=0.3.0"
+version = "=0.4.0"
 
 [dependencies.darling_macro]
-version = "=0.3.0"
+version = "=0.4.0"
 [dev-dependencies.quote]
-version = "0.4"
+version = "0.5"
 
 [dev-dependencies.syn]
-version = "0.12.10"
+version = "0.13"
 [badges.travis-ci]
 repository = "TedDriggs/darling"
--- a/third_party/rust/darling_core/.cargo-checksum.json
+++ b/third_party/rust/darling_core/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"64569afb788cd8b08c9d13a994f39b9123138f0391cd2aa989d4949eadaf09ad","src/ast.rs":"2538b41e2a579c0a5a49e02f911120ffff39d48dfc0d80570a5fcfe95c971794","src/codegen/default_expr.rs":"8cea4bf29096ad1add5325430a12865173a13a821e1888bed8120ec6120a7764","src/codegen/error.rs":"2a1bde9a20c664f26c6a0017e35ddf82885a31b8be42a628ea5549013b1eab44","src/codegen/field.rs":"ad8355c7bb87269c7dcc1d27695b0f8de410b546625d33d5a219fbadf85f8230","src/codegen/fmi_impl.rs":"89a66b24d7527989dd90ca71d9409fd8cdcf3a659fa1a670448032a4b384e83c","src/codegen/from_derive_impl.rs":"36507c9eddd354a50f96cd28e737c914be494c83ae61202b533524a9d90a2ca9","src/codegen/from_field.rs":"586866442f6628fd055f139b018a8c5c13e3aea20954ec741517aa9ab731c163","src/codegen/from_variant_impl.rs":"d42ecd82d3159aa7ee89ed81ed355c927dea9df2a298cf1db0c486699b77eac2","src/codegen/mod.rs":"46cdb1b4a76eb2e56f01e2c9e2879aed9b1c21ecbed42575a2eeccabf446a27a","src/codegen/outer_from_impl.rs":"a484fc3faed8a722327df18cb5179812b60ff62795a3b00b2b968a40bddec52a","src/codegen/trait_impl.rs":"715ce9dcb82d855e9dd8f2a70599bc3c5328acde70c92b7db5bd4c276598a7d0","src/codegen/variant.rs":"294045aefcfcb54e8b9536d6d91251a46115271869578b3212ae36ae76883b18","src/codegen/variant_data.rs":"efdee90d7e9acce39672024502ceb0616bc162d11e59d255fcbcd23f00f80806","src/error.rs":"55f33c960123799e1ccb27676d780751c0b62d1f52ccb9a2ac69cea4acfe55db","src/from_derive_input.rs":"ea55cc1b2bc17495d36fb616f7cd7aa78e4b74ea7c8554eed9d392ee853700c3","src/from_field.rs":"b42c2fc037aebdd55f195d722ba20075d3e095f03e89890a0d37d406d6419d87","src/from_meta_item.rs":"c4cf05c3649db57ead2d7fd6ae3973b08e74ad20022ac62a7e5e49aa74a46a57","src/from_variant.rs":"2baeb09c8a95ff606d9d5ca8992f10bbad9c4925590332af1a8b5bdae54ebae8","src/lib.rs":"e8b381a74c9303a620e7f210174bfab4c44e3137cba387a9547376982e3fb10a","src/macros.rs":"ff0c87953220702d8440894a7f0f557b1aae930096663c0c98e7ca686a94f305","src/options/core.rs":"689067ee0901714e53caeef5d5634c4bc02f52ff06e3ff286410eecaca665734","src/options/forward_attrs.rs":"35a83a4ae695872413d964d9050e35a0075c8386c286d291b1ecf1779f9ba8a3","src/options/from_derive.rs":"502e18c3d9f90d7a4cebc8c6b60181ab6068958a0ba2e70fe645528dee34b231","src/options/from_field.rs":"7222be5e62026184169f12adb08403abc89d66c53e678f8d8b43afaeceed9e4f","src/options/from_meta_item.rs":"cbc2d747e9e35e0d68b26c9f1592914bb4924cac01a6cdaf9137f643a72b551a","src/options/from_variant.rs":"6f8538da3fb61e614552839ee32bc479d33b5227d7f9d9b357d8d05146b96dac","src/options/input_field.rs":"364c7a30d0c320197062706ba12507742b97513bb64a644243b03210ef3bb334","src/options/input_variant.rs":"2fc064fb87a73542a012a31aa5fd9702cf58b52a1bf37dabbfa7fb2e758ff9cc","src/options/mod.rs":"ceefde4d1dba9b5f3822f667c34a6eb963e5a899973475456bfe7939177f0e19","src/options/outer_from.rs":"3125aad9f8c033727fd3ef4ef1e1881c77fa52463f78342c408bf135e8533037","src/options/shape.rs":"118af560da80a46d6e3f8980c3d9b4863319d224a8b2985520901bfea0eba531","src/util/ident_list.rs":"11b5008380ace89d5745cdd83b73a2841c5382f05d3a8942ba998a7e4d6abb31","src/util/ignored.rs":"89e0b5bc0f9dd8b77a63d5c1b7b3a7bb4b68d539fb97efe0d86cd1dbb46be1e8","src/util/mod.rs":"0c9ee0ba8ec03ca654fd298bd0d82588f224e3743227e6cba2beba4ab2f4dee4","src/util/over_ride.rs":"f63637ff73b3f377a4b1c38714a0f108b98ff40a96dd3ffbebb1e4ecc7523813"},"package":"167dd3e235c2f1da16a635c282630452cdf49191eb05711de1bcd1d3d5068c00"}
\ No newline at end of file
+{"files":{"Cargo.toml":"06561e115990be3f278ed12704d0eb575c971242cbdfe8ebb32a8132280e054e","src/ast.rs":"2538b41e2a579c0a5a49e02f911120ffff39d48dfc0d80570a5fcfe95c971794","src/codegen/default_expr.rs":"28d750fb5ed3a6344007bf545c48e4d9a15c175209903d4009efc0de257adf2e","src/codegen/error.rs":"2a1bde9a20c664f26c6a0017e35ddf82885a31b8be42a628ea5549013b1eab44","src/codegen/field.rs":"ad8355c7bb87269c7dcc1d27695b0f8de410b546625d33d5a219fbadf85f8230","src/codegen/fmi_impl.rs":"89a66b24d7527989dd90ca71d9409fd8cdcf3a659fa1a670448032a4b384e83c","src/codegen/from_derive_impl.rs":"36507c9eddd354a50f96cd28e737c914be494c83ae61202b533524a9d90a2ca9","src/codegen/from_field.rs":"586866442f6628fd055f139b018a8c5c13e3aea20954ec741517aa9ab731c163","src/codegen/from_variant_impl.rs":"d42ecd82d3159aa7ee89ed81ed355c927dea9df2a298cf1db0c486699b77eac2","src/codegen/mod.rs":"46cdb1b4a76eb2e56f01e2c9e2879aed9b1c21ecbed42575a2eeccabf446a27a","src/codegen/outer_from_impl.rs":"2314c1594bd63e682ebd4a4b4954b2b9f16aa50b1422c05568bce97ae29f9727","src/codegen/trait_impl.rs":"715ce9dcb82d855e9dd8f2a70599bc3c5328acde70c92b7db5bd4c276598a7d0","src/codegen/variant.rs":"294045aefcfcb54e8b9536d6d91251a46115271869578b3212ae36ae76883b18","src/codegen/variant_data.rs":"efdee90d7e9acce39672024502ceb0616bc162d11e59d255fcbcd23f00f80806","src/error.rs":"55f33c960123799e1ccb27676d780751c0b62d1f52ccb9a2ac69cea4acfe55db","src/from_derive_input.rs":"ea55cc1b2bc17495d36fb616f7cd7aa78e4b74ea7c8554eed9d392ee853700c3","src/from_field.rs":"b42c2fc037aebdd55f195d722ba20075d3e095f03e89890a0d37d406d6419d87","src/from_meta_item.rs":"996ccec9dca998ff41f65bb346e5cc75952af5d61339c6951bebdbf8db1212c5","src/from_variant.rs":"2baeb09c8a95ff606d9d5ca8992f10bbad9c4925590332af1a8b5bdae54ebae8","src/lib.rs":"58b910cecc1f1962c2d6059db384f065099547c34631d9ddcc35099db8e16405","src/macros.rs":"ef249cd9ca593aac423b4242df1c39c31610438da094c21562d74a7e5823c700","src/options/core.rs":"689067ee0901714e53caeef5d5634c4bc02f52ff06e3ff286410eecaca665734","src/options/forward_attrs.rs":"35a83a4ae695872413d964d9050e35a0075c8386c286d291b1ecf1779f9ba8a3","src/options/from_derive.rs":"502e18c3d9f90d7a4cebc8c6b60181ab6068958a0ba2e70fe645528dee34b231","src/options/from_field.rs":"7222be5e62026184169f12adb08403abc89d66c53e678f8d8b43afaeceed9e4f","src/options/from_meta_item.rs":"cbc2d747e9e35e0d68b26c9f1592914bb4924cac01a6cdaf9137f643a72b551a","src/options/from_variant.rs":"6f8538da3fb61e614552839ee32bc479d33b5227d7f9d9b357d8d05146b96dac","src/options/input_field.rs":"6d43c2907694c4187e9f182f7945fc769ce210cde8eb1b4a336dea2a7fce3710","src/options/input_variant.rs":"2fc064fb87a73542a012a31aa5fd9702cf58b52a1bf37dabbfa7fb2e758ff9cc","src/options/mod.rs":"ceefde4d1dba9b5f3822f667c34a6eb963e5a899973475456bfe7939177f0e19","src/options/outer_from.rs":"3125aad9f8c033727fd3ef4ef1e1881c77fa52463f78342c408bf135e8533037","src/options/shape.rs":"118af560da80a46d6e3f8980c3d9b4863319d224a8b2985520901bfea0eba531","src/util/ident_list.rs":"11b5008380ace89d5745cdd83b73a2841c5382f05d3a8942ba998a7e4d6abb31","src/util/ignored.rs":"66e2e3201e17e8fffe2f249a4327b8178a20304624a47c0149fe8dd5e05d187c","src/util/mod.rs":"0c9ee0ba8ec03ca654fd298bd0d82588f224e3743227e6cba2beba4ab2f4dee4","src/util/over_ride.rs":"f63637ff73b3f377a4b1c38714a0f108b98ff40a96dd3ffbebb1e4ecc7523813"},"package":"b315f49c7b6db3708bca6e6913c194581a44ec619b7a39e131d4dd63733a3698"}
\ No newline at end of file
--- a/third_party/rust/darling_core/Cargo.toml
+++ b/third_party/rust/darling_core/Cargo.toml
@@ -7,25 +7,28 @@
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
 # editing this file be aware that the upstream Cargo.toml
 # will likely look very different (and much more reasonable)
 
 [package]
 name = "darling_core"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
 description = "Helper crate for proc-macro library for reading attributes into structs when\nimplementing custom derives. Use https://crates.io/crates/darling in your code.\n"
 license = "MIT"
 repository = "https://github.com/TedDriggs/darling"
 [dependencies.ident_case]
 version = "1.0.0"
 
+[dependencies.proc-macro2]
+version = "0.3"
+
 [dependencies.quote]
-version = "0.4"
+version = "0.5"
 
 [dependencies.syn]
-version = "0.12.10"
+version = "0.13"
 features = ["extra-traits"]
 
 [features]
 default = ["syn/full"]
--- a/third_party/rust/darling_core/src/codegen/default_expr.rs
+++ b/third_party/rust/darling_core/src/codegen/default_expr.rs
@@ -19,27 +19,27 @@ impl<'a> DefaultExpression<'a> {
         DefaultDeclaration(self)
     }
 }
 
 impl<'a> ToTokens for DefaultExpression<'a> {
     fn to_tokens(&self, tokens: &mut Tokens) {
         tokens.append_all(match *self {
             DefaultExpression::Inherit(ident) => {
-                let dsn = Ident::from(DEFAULT_STRUCT_NAME);
+                let dsn = Ident::new(DEFAULT_STRUCT_NAME, ::proc_macro2::Span::call_site());
                 quote!(#dsn.#ident)
             },
             DefaultExpression::Explicit(path) => quote!(#path()),
             DefaultExpression::Trait => quote!(::darling::export::Default::default()),
         });
     }
 }
 
 /// Used only by containers, this wrapper type generates code to declare the fallback instance.
 pub struct DefaultDeclaration<'a>(&'a DefaultExpression<'a>);
 
 impl<'a> ToTokens for DefaultDeclaration<'a> {
     fn to_tokens(&self, tokens: &mut Tokens) {
-        let name = Ident::from(DEFAULT_STRUCT_NAME);
+        let name = Ident::new(DEFAULT_STRUCT_NAME, ::proc_macro2::Span::call_site());
         let expr = self.0;
         tokens.append_all(quote!(let #name: Self = #expr;));
     }
 }
--- a/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
@@ -32,16 +32,17 @@ pub trait OuterFromImpl<'a> {
 }
 
 fn compute_impl_bounds(bound: Path, mut generics: Generics) -> Generics {
     if generics.params.is_empty() {
         return generics;
     }
 
     let added_bound = TypeParamBound::Trait(TraitBound {
+            paren_token: None,
             modifier: TraitBoundModifier::None,
             lifetimes: None,
             path: bound,
         });
 
     for mut param in generics.params.iter_mut() {
         if let &mut GenericParam::Type(ref mut typ) = param {
             typ.bounds.push(added_bound.clone());
--- a/third_party/rust/darling_core/src/from_meta_item.rs
+++ b/third_party/rust/darling_core/src/from_meta_item.rs
@@ -187,17 +187,17 @@ impl FromMetaItem for i64 {
 impl FromMetaItem for isize {
     fn from_string(s: &str) -> Result<Self> {
         s.parse().or_else(|_| Err(Error::unknown_value(s)))
     }
 }
 
 impl FromMetaItem for syn::Ident {
     fn from_string(value: &str) -> Result<Self> {
-        Ok(syn::Ident::from(value))
+        Ok(syn::Ident::new(value, ::proc_macro2::Span::call_site()))
     }
 }
 
 impl FromMetaItem for syn::Path {
     fn from_string(value: &str) -> Result<Self> {
         Ok(syn::parse_str::<syn::Path>(value).unwrap())
     }
 }
--- a/third_party/rust/darling_core/src/lib.rs
+++ b/third_party/rust/darling_core/src/lib.rs
@@ -1,15 +1,16 @@
 #![recursion_limit = "256"]
 
 #[macro_use]
 extern crate quote;
 
 #[macro_use]
 extern crate syn;
+extern crate proc_macro2;
 
 extern crate ident_case;
 
 #[macro_use]
 mod macros;
 
 pub mod ast;
 pub mod codegen;
--- a/third_party/rust/darling_core/src/macros.rs
+++ b/third_party/rust/darling_core/src/macros.rs
@@ -1,6 +1,12 @@
+macro_rules! quote {
+    ($($tt:tt)*) => {
+        quote_spanned!(::proc_macro2::Span::call_site() => $($tt)*)
+    };
+}
+
 macro_rules! path {
     ($($path:tt)+) => {
         parse_quote!($($path)+)
         //stringify!($($path)+).parse().unwrap()
     };
 }
--- a/third_party/rust/darling_core/src/options/input_field.rs
+++ b/third_party/rust/darling_core/src/options/input_field.rs
@@ -56,17 +56,17 @@ impl InputField {
             with: None,
             skip: false,
             map: Default::default(),
             multiple: false,
         }
     }
 
     pub fn from_field(f: &syn::Field, parent: Option<&Core>) -> Result<Self> {
-        let ident = f.ident.clone().unwrap_or(syn::Ident::from("__unnamed"));
+        let ident = f.ident.clone().unwrap_or(syn::Ident::new("__unnamed", ::proc_macro2::Span::call_site()));
         let ty = f.ty.clone();
         let base = Self::new(ident, ty).parse_attributes(&f.attrs)?;
 
         if let Some(container) = parent {
             base.with_inherited(container)
         } else {
             Ok(base)
         }
--- a/third_party/rust/darling_core/src/util/ignored.rs
+++ b/third_party/rust/darling_core/src/util/ignored.rs
@@ -1,17 +1,17 @@
 use syn;
 
 use {FromMetaItem, FromDeriveInput, FromField, FromVariant, Result};
 
 /// An efficient way of discarding data from an attribute.
 ///
 /// All meta-items, fields, and variants will be successfully read into
 /// the `Ignored` struct, with all properties discarded.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub struct Ignored;
 
 impl FromMetaItem for Ignored {
     fn from_meta_item(_: &syn::Meta) -> Result<Self> {
         Ok(Ignored)
     }
 
     fn from_nested_meta_item(_: &syn::NestedMeta) -> Result<Self> {
--- a/third_party/rust/darling_macro/.cargo-checksum.json
+++ b/third_party/rust/darling_macro/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"24ebe6f6d1e4bd5ca3dd416bda62ab1d12d05f6990d30cff0fd301cc83273ecc","src/lib.rs":"d900da894985945215cb4494ebd4e8b5f697c19bf9e624a1bb03d22a0a5367a5"},"package":"c53edaba455f6073a10c27c72440860eb3f60444f8c8660a391032eeae744d82"}
\ No newline at end of file
+{"files":{"Cargo.toml":"cf9d579ee6af881a7aa52d43d637b4afa9cf589bfda3fa63159538d681855330","src/lib.rs":"d900da894985945215cb4494ebd4e8b5f697c19bf9e624a1bb03d22a0a5367a5"},"package":"eb69a38fdeaeaf3db712e1df170de67ee9dfc24fb88ca3e9d21e703ec25a4d8e"}
\ No newline at end of file
--- a/third_party/rust/darling_macro/Cargo.toml
+++ b/third_party/rust/darling_macro/Cargo.toml
@@ -7,24 +7,24 @@
 #
 # If you believe there's an error in this file please file an
 # issue against the rust-lang/cargo repository. If you're
 # editing this file be aware that the upstream Cargo.toml
 # will likely look very different (and much more reasonable)
 
 [package]
 name = "darling_macro"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["Ted Driggs <ted.driggs@outlook.com>"]
 description = "Internal support for a proc-macro library for reading attributes into structs when\nimplementing custom derives. Use https://crates.io/crates/darling in your code.\n"
 license = "MIT"
 repository = "https://github.com/TedDriggs/darling"
 
 [lib]
 proc-macro = true
 [dependencies.darling_core]
-version = "=0.3.0"
+version = "=0.4.0"
 
 [dependencies.quote]
-version = "0.4"
+version = "0.5"
 
 [dependencies.syn]
-version = "0.12"
+version = "0.13"
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"e455a0ed5c3dd056d31f4c7be088bc94f21cab6595a23f2f015b1efc0ac2b55c","Cargo.toml":"0b700f1e7b8ba76ce4678d36b6906d38455e88f51085ea9f120d6ca63f13d5d7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","README.md":"adf2e822923878c2ebf4a0a782898c598fc6f57a3af905b85d57fc716c836687","src/lib.rs":"fbae25504264b185d877fb8784d4d88333ea34a7cbeddca3277dc8421f179933","src/macros.rs":"414505e520b8d705b4ce5a64ec2e82d6d1af0b88567454169486a668fbc1e9c8","src/stable.rs":"6363c4c0ef989c2ec81aa75be71c69a103d45a1de439f3f3bcb6806d8a78a172","src/strnom.rs":"1baded8543a9930798fb16092fe51e9074591902e327e0f94eb1c908a6370de9","src/unstable.rs":"110d27103e37427b3d1dcb45b6ba9dc9f5641a255766a43d5db0f4fd10a341ed","tests/test.rs":"9e75d5289abc1dc58c1df00ae051d8c3cd2c0d7830cca5ad689007c05acffe26"},"package":"d1cb7aaaa4bf022ec2b14ff2f2ba1643a22f3cee88df014a85e14b392282c61d"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/.travis.yml
+++ /dev/null
@@ -1,31 +0,0 @@
-language: rust
-sudo: false
-
-matrix:
-  include:
-    - rust: 1.15.0
-    - rust: stable
-    - rust: beta
-    - rust: nightly
-      before_script:
-        - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-      script:
-        - cargo test
-        - cargo build --features nightly
-        - RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo test
-        - RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build --features nightly
-        - RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo doc --no-deps
-      after_success:
-        - travis-cargo --only nightly doc-upload
-
-script:
-  - cargo test
-  - RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo test
-env:
-  global:
-    - TRAVIS_CARGO_NIGHTLY_FEATURE=""
-    - secure: "NAsZghAVTAksrm4WP4I66VmD2wW0eRbwB+ZKHUQfvbgUaCRvVdp4WBbWXGU/f/yHgDFWZwljWR4iPMiBwAK8nZsQFRuLFdHrOOHqbkj639LLdT9A07s1zLMB1GfR1fDttzrGhm903pbT2yxSyqqpahGYM7TaGDYYmKYIk4XyVNA5F5Sk7RI+rCecKraoYDeUEFbjWWYtU2FkEXsELEKj0emX5reWkR+wja3QokFcRZ25+Zd2dRC0K8W5QcY2UokLzKncBMCTC5q70H616S3r/9qW67Si1njsJ7RzP0NlZQUNQ/VCvwr4LCr9w+AD9i1SZtXxuux77tWEWSJvBzUc82dDMUv/floJuF7HTulSxxQoRm+fbzpXj9mgaJNiUHXru6ZRTCRVRUSXpcAco94bVoy/jnjrTe3jgAIZK5w14zA8yLw1Jxof31DlbcWORxgF+6fnY2nKPRN2oiQ50+jm1AuGDZX59/wMiu1QlkjOBHtikHp+u+7mp3SkkM04DvuQ/tWODQQnOOtrA0EB3i5H1zeTSnUcmbJufUljWWOvF1QYII08MccqwfG1KWbpobvdu+cV2iVhkq/lNCEL3Ai101CnmSCnMz+9oK/XxYOrx2TnaD9ootOKgnk7XWxF19GZecQx6O2hHTouxvB/0KcRPGWmMWl0H88f3T/Obql8bG8="
-
-notifications:
-  email:
-    on_success: never
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "proc-macro2"
-version = "0.2.2"
-authors = ["Alex Crichton <alex@alexcrichton.com>"]
-description = "A stable implementation of the upcoming new `proc_macro` API. Comes with an\noption, off by default, to also reimplement itself in terms of the upstream\nunstable API.\n"
-homepage = "https://github.com/alexcrichton/proc-macro2"
-documentation = "https://docs.rs/proc-macro2"
-readme = "README.md"
-keywords = ["macros"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/alexcrichton/proc-macro2"
-
-[lib]
-doctest = false
-[dependencies.unicode-xid]
-version = "0.1"
-
-[features]
-nightly = []
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2014 Alex Crichton
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/README.md
+++ /dev/null
@@ -1,98 +0,0 @@
-# proc-macro2
-
-[![Build Status](https://api.travis-ci.org/alexcrichton/proc-macro2.svg?branch=master)](https://travis-ci.org/alexcrichton/proc-macro2)
-[![Latest Version](https://img.shields.io/crates/v/proc-macro2.svg)](https://crates.io/crates/proc-macro2)
-[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/proc-macro2)
-
-A small shim over the `proc_macro` crate in the compiler intended to multiplex
-the current stable interface (as of 2017-07-05) and the [upcoming richer
-interface][upcoming].
-
-[upcoming]: https://github.com/rust-lang/rust/pull/40939
-
-The upcoming support has features like:
-
-* Span information on tokens
-* No need to go in/out through strings
-* Structured input/output
-
-The hope is that libraries ported to `proc_macro2` will be trivial to port to
-the real `proc_macro` crate once the support on nightly is stabilize.
-
-## Usage
-
-This crate by default compiles on the stable version of the compiler. It only
-uses the stable surface area of the `proc_macro` crate upstream in the compiler
-itself. Usage is done via:
-
-```toml
-[dependencies]
-proc-macro2 = "0.2"
-```
-
-followed by
-
-```rust
-extern crate proc_macro;
-extern crate proc_macro2;
-
-#[proc_macro_derive(MyDerive)]
-pub fn my_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    let input: proc_macro2::TokenStream = input.into();
-
-    let output: proc_macro2::TokenStream = {
-        /* transform input */
-    };
-
-    output.into()
-}
-```
-
-If you'd like you can enable the `nightly` feature in this crate. This will
-cause it to compile against the **unstable and nightly-only** features of the
-`proc_macro` crate. This in turn requires a nightly compiler. This should help
-preserve span information, however, coming in from the compiler itself.
-
-You can enable this feature via:
-
-```toml
-[dependencies]
-proc-macro2 = { version = "0.2", features = ["nightly"] }
-```
-
-
-## Unstable Features
-
-`proc-macro2` supports exporting some methods from `proc_macro` which are
-currently highly unstable, and may not be stabilized in the first pass of
-`proc_macro` stabilizations. These features are not exported by default. Minor
-versions of `proc-macro2` may make breaking changes to them at any time.
-
-To enable these features, the `procmacro2_semver_exempt` config flag must be
-passed to rustc.
-
-```
-RUSTFLAGS='--cfg procmacro2_semver_exempt' cargo build
-```
-
-Note that this must not only be done for your crate, but for any crate that
-depends on your crate. This infectious nature is intentional, as it serves as a
-reminder that you are outside of the normal semver guarantees.
-
-
-# License
-
-This project is licensed under either of
-
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/src/lib.rs
+++ /dev/null
@@ -1,337 +0,0 @@
-//! A "shim crate" intended to multiplex the `proc_macro` API on to stable Rust.
-//!
-//! Procedural macros in Rust operate over the upstream
-//! `proc_macro::TokenStream` type. This type currently is quite conservative
-//! and exposed no internal implementation details. Nightly compilers, however,
-//! contain a much richer interface. This richer interface allows fine-grained
-//! inspection of the token stream which avoids stringification/re-lexing and
-//! also preserves span information.
-//!
-//! The upcoming APIs added to `proc_macro` upstream are the foundation for
-//! productive procedural macros in the ecosystem. To help prepare the ecosystem
-//! for using them this crate serves to both compile on stable and nightly and
-//! mirrors the API-to-be. The intention is that procedural macros which switch
-//! to use this crate will be trivially able to switch to the upstream
-//! `proc_macro` crate once its API stabilizes.
-//!
-//! In the meantime this crate also has a `nightly` Cargo feature which
-//! enables it to reimplement itself with the unstable API of `proc_macro`.
-//! This'll allow immediate usage of the beneficial upstream API, particularly
-//! around preserving span information.
-
-// Proc-macro2 types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/proc-macro2/0.2.2")]
-
-#![cfg_attr(feature = "nightly", feature(proc_macro))]
-
-extern crate proc_macro;
-
-#[cfg(not(feature = "nightly"))]
-extern crate unicode_xid;
-
-use std::fmt;
-use std::str::FromStr;
-use std::iter::FromIterator;
-
-#[macro_use]
-#[cfg(not(feature = "nightly"))]
-mod strnom;
-
-#[path = "stable.rs"]
-#[cfg(not(feature = "nightly"))]
-mod imp;
-#[path = "unstable.rs"]
-#[cfg(feature = "nightly")]
-mod imp;
-
-#[macro_use]
-mod macros;
-
-#[derive(Clone)]
-pub struct TokenStream(imp::TokenStream);
-
-pub struct LexError(imp::LexError);
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        match src.parse() {
-            Ok(e) => Ok(TokenStream(e)),
-            Err(e) => Err(LexError(e)),
-        }
-    }
-}
-
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        TokenStream(inner.into())
-    }
-}
-
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        inner.0.into()
-    }
-}
-
-impl From<TokenTree> for TokenStream {
-    fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(tree.into())
-    }
-}
-
-impl<T: Into<TokenStream>> FromIterator<T> for TokenStream {
-    fn from_iter<I: IntoIterator<Item = T>>(streams: I) -> Self {
-        TokenStream(streams.into_iter().map(|t| t.into().0).collect())
-    }
-}
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = TokenTreeIter;
-
-    fn into_iter(self) -> TokenTreeIter {
-        TokenTreeIter(self.0.into_iter())
-    }
-}
-
-impl TokenStream {
-    pub fn empty() -> TokenStream {
-        TokenStream(imp::TokenStream::empty())
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-// Returned by reference, so we can't easily wrap it.
-#[cfg(procmacro2_semver_exempt)]
-pub use imp::FileName;
-
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, PartialEq, Eq)]
-pub struct SourceFile(imp::SourceFile);
-
-#[cfg(procmacro2_semver_exempt)]
-impl SourceFile {
-    /// Get the path to this source file as a string.
-    pub fn path(&self) -> &FileName {
-        self.0.path()
-    }
-
-    pub fn is_real(&self) -> bool {
-        self.0.is_real()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl AsRef<FileName> for SourceFile {
-    fn as_ref(&self) -> &FileName {
-        self.0.path()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl fmt::Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-pub struct LineColumn {
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Copy, Clone)]
-pub struct Span(imp::Span);
-
-impl Span {
-    pub fn call_site() -> Span {
-        Span(imp::Span::call_site())
-    }
-
-    pub fn def_site() -> Span {
-        Span(imp::Span::def_site())
-    }
-
-    /// Creates a new span with the same line/column information as `self` but
-    /// that resolves symbols as though it were at `other`.
-    pub fn resolved_at(&self, other: Span) -> Span {
-        Span(self.0.resolved_at(other.0))
-    }
-
-    /// Creates a new span with the same name resolution behavior as `self` but
-    /// with the line/column information of `other`.
-    pub fn located_at(&self, other: Span) -> Span {
-        Span(self.0.located_at(other.0))
-    }
-
-    /// This method is only available when the `"nightly"` feature is enabled.
-    #[cfg(feature = "nightly")]
-    pub fn unstable(self) -> proc_macro::Span {
-        self.0.unstable()
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn source_file(&self) -> SourceFile {
-        SourceFile(self.0.source_file())
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn start(&self) -> LineColumn {
-        let imp::LineColumn{ line, column } = self.0.start();
-        LineColumn { line: line, column: column }
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn end(&self) -> LineColumn {
-        let imp::LineColumn{ line, column } = self.0.end();
-        LineColumn { line: line, column: column }
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn join(&self, other: Span) -> Option<Span> {
-        self.0.join(other.0).map(Span)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct TokenTree {
-    pub span: Span,
-    pub kind: TokenNode,
-}
-
-impl From<TokenNode> for TokenTree {
-    fn from(kind: TokenNode) -> TokenTree {
-        TokenTree { span: Span::def_site(), kind: kind }
-    }
-}
-
-impl fmt::Display for TokenTree {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        TokenStream::from(self.clone()).fmt(f)
-    }
-}
-
-#[derive(Clone, Debug)]
-pub enum TokenNode {
-    Group(Delimiter, TokenStream),
-    Term(Term),
-    Op(char, Spacing),
-    Literal(Literal),
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Delimiter {
-    Parenthesis,
-    Brace,
-    Bracket,
-    None,
-}
-
-#[derive(Copy, Clone)]
-pub struct Term(imp::Term);
-
-impl Term {
-    pub fn intern(string: &str) -> Term {
-        Term(imp::Term::intern(string))
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub enum Spacing {
-    Alone,
-    Joint,
-}
-
-#[derive(Clone)]
-pub struct Literal(imp::Literal);
-
-macro_rules! int_literals {
-    ($($kind:ident,)*) => ($(
-        pub fn $kind(n: $kind) -> Literal {
-            Literal(n.into())
-        }
-    )*)
-}
-
-impl Literal {
-    pub fn integer(s: i64) -> Literal {
-        Literal(imp::Literal::integer(s))
-    }
-
-    int_literals! {
-        u8, u16, u32, u64, usize,
-        i8, i16, i32, i64, isize,
-    }
-
-    pub fn float(f: f64) -> Literal {
-        Literal(imp::Literal::float(f))
-    }
-
-    pub fn f64(f: f64) -> Literal {
-        Literal(f.into())
-    }
-
-    pub fn f32(f: f32) -> Literal {
-        Literal(f.into())
-    }
-
-    pub fn string(string: &str) -> Literal {
-        Literal(string.into())
-    }
-
-    pub fn character(ch: char) -> Literal {
-        Literal(ch.into())
-    }
-
-    pub fn byte_string(s: &[u8]) -> Literal {
-        Literal(imp::Literal::byte_string(s))
-    }
-
-    // =======================================================================
-    // Not present upstream in proc_macro yet
-
-    pub fn byte_char(b: u8) -> Literal {
-        Literal(imp::Literal::byte_char(b))
-    }
-
-    pub fn doccomment(s: &str) -> Literal {
-        Literal(imp::Literal::doccomment(s))
-    }
-
-    pub fn raw_string(s: &str, pounds: usize) -> Literal {
-        Literal(imp::Literal::raw_string(s, pounds))
-    }
-
-    pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
-        Literal(imp::Literal::raw_byte_string(s, pounds))
-    }
-}
-
-pub struct TokenTreeIter(imp::TokenTreeIter);
-
-impl Iterator for TokenTreeIter {
-    type Item = TokenTree;
-
-    fn next(&mut self) -> Option<TokenTree> {
-        self.0.next()
-    }
-}
-
-forward_fmt!(Debug for LexError);
-forward_fmt!(Debug for Literal);
-forward_fmt!(Debug for Span);
-forward_fmt!(Debug for Term);
-forward_fmt!(Debug for TokenTreeIter);
-forward_fmt!(Debug for TokenStream);
-forward_fmt!(Display for Literal);
-forward_fmt!(Display for TokenStream);
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/src/macros.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-macro_rules! forward_fmt {
-    ($tr:ident for $ty:ident) => {
-        impl ::std::fmt::$tr for $ty {
-            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                ::std::fmt::$tr::fmt(&self.0, f)
-            }
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/src/stable.rs
+++ /dev/null
@@ -1,1206 +0,0 @@
-use std::ascii;
-use std::borrow::Borrow;
-use std::cell::RefCell;
-#[cfg(procmacro2_semver_exempt)]
-use std::cmp;
-use std::collections::HashMap;
-use std::fmt;
-use std::iter;
-use std::marker::PhantomData;
-use std::rc::Rc;
-use std::str::FromStr;
-use std::vec;
-
-use proc_macro;
-use unicode_xid::UnicodeXID;
-use strnom::{Cursor, PResult, skip_whitespace, block_comment, whitespace, word_break};
-
-use {TokenTree, TokenNode, Delimiter, Spacing};
-
-#[derive(Clone, Debug)]
-pub struct TokenStream {
-    inner: Vec<TokenTree>,
-}
-
-#[derive(Debug)]
-pub struct LexError;
-
-impl TokenStream {
-    pub fn empty() -> TokenStream {
-        TokenStream { inner: Vec::new() }
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.inner.len() == 0
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-fn get_cursor(src: &str) -> Cursor {
-    // Create a dummy file & add it to the codemap
-    CODEMAP.with(|cm| {
-        let mut cm = cm.borrow_mut();
-        let name = format!("<parsed string {}>", cm.files.len());
-        let span = cm.add_file(&name, src);
-        Cursor {
-            rest: src,
-            off: span.lo,
-        }
-    })
-}
-
-#[cfg(not(procmacro2_semver_exempt))]
-fn get_cursor(src: &str) -> Cursor {
-    Cursor {
-        rest: src,
-    }
-}
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        // Create a dummy file & add it to the codemap
-        let cursor = get_cursor(src);
-
-        match token_stream(cursor) {
-            Ok((input, output)) => {
-                if skip_whitespace(input).len() != 0 {
-                    Err(LexError)
-                } else {
-                    Ok(output.0)
-                }
-            }
-            Err(LexError) => Err(LexError),
-        }
-    }
-}
-
-impl fmt::Display for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut joint = false;
-        for (i, tt) in self.inner.iter().enumerate() {
-            if i != 0 && !joint {
-                write!(f, " ")?;
-            }
-            joint = false;
-            match tt.kind {
-                TokenNode::Group(delim, ref stream) => {
-                    let (start, end) = match delim {
-                        Delimiter::Parenthesis => ("(", ")"),
-                        Delimiter::Brace => ("{", "}"),
-                        Delimiter::Bracket => ("[", "]"),
-                        Delimiter::None => ("", ""),
-                    };
-                    if stream.0.inner.len() == 0 {
-                        write!(f, "{} {}", start, end)?
-                    } else {
-                        write!(f, "{} {} {}", start, stream, end)?
-                    }
-                }
-                TokenNode::Term(ref sym) => write!(f, "{}", sym.as_str())?,
-                TokenNode::Op(ch, ref op) => {
-                    write!(f, "{}", ch)?;
-                    match *op {
-                        Spacing::Alone => {}
-                        Spacing::Joint => joint = true,
-                    }
-                }
-                TokenNode::Literal(ref literal) => {
-                    write!(f, "{}", literal)?;
-                    // handle comments
-                    if (literal.0).0.starts_with("/") {
-                        write!(f, "\n")?;
-                    }
-                }
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        inner.to_string().parse().expect("compiler token stream parse failed")
-    }
-}
-
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        inner.to_string().parse().expect("failed to parse to compiler tokens")
-    }
-}
-
-
-impl From<TokenTree> for TokenStream {
-    fn from(tree: TokenTree) -> TokenStream {
-        TokenStream { inner: vec![tree] }
-    }
-}
-
-impl iter::FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item=TokenStream>>(streams: I) -> Self {
-        let mut v = Vec::new();
-
-        for stream in streams.into_iter() {
-            v.extend(stream.inner);
-        }
-
-        TokenStream { inner: v }
-    }
-}
-
-pub type TokenTreeIter = vec::IntoIter<TokenTree>;
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = TokenTreeIter;
-
-    fn into_iter(self) -> TokenTreeIter {
-        self.inner.into_iter()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, PartialEq, Eq, Debug)]
-pub struct FileName(String);
-
-#[cfg(procmacro2_semver_exempt)]
-impl fmt::Display for FileName {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, PartialEq, Eq)]
-pub struct SourceFile {
-    name: FileName,
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl SourceFile {
-    /// Get the path to this source file as a string.
-    pub fn path(&self) -> &FileName {
-        &self.name
-    }
-
-    pub fn is_real(&self) -> bool {
-        // XXX(nika): Support real files in the future?
-        false
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl AsRef<FileName> for SourceFile {
-    fn as_ref(&self) -> &FileName {
-        self.path()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl fmt::Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("SourceFile")
-            .field("path", &self.path())
-            .field("is_real", &self.is_real())
-            .finish()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub struct LineColumn {
-    pub line: usize,
-    pub column: usize,
-}
-
-#[cfg(procmacro2_semver_exempt)]
-thread_local! {
-    static CODEMAP: RefCell<Codemap> = RefCell::new(Codemap {
-        // NOTE: We start with a single dummy file which all call_site() and
-        // def_site() spans reference.
-        files: vec![FileInfo {
-            name: "<unspecified>".to_owned(),
-            span: Span { lo: 0, hi: 0 },
-            lines: vec![0],
-        }],
-    });
-}
-
-#[cfg(procmacro2_semver_exempt)]
-struct FileInfo {
-    name: String,
-    span: Span,
-    lines: Vec<usize>,
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl FileInfo {
-    fn offset_line_column(&self, offset: usize) -> LineColumn {
-        assert!(self.span_within(Span { lo: offset as u32, hi: offset as u32 }));
-        let offset = offset - self.span.lo as usize;
-        match self.lines.binary_search(&offset) {
-            Ok(found) => LineColumn {
-                line: found + 1,
-                column: 0
-            },
-            Err(idx) => LineColumn {
-                line: idx,
-                column: offset - self.lines[idx - 1]
-            },
-        }
-    }
-
-    fn span_within(&self, span: Span) -> bool {
-        span.lo >= self.span.lo && span.hi <= self.span.hi
-    }
-}
-
-/// Computes the offsets of each line in the given source string.
-#[cfg(procmacro2_semver_exempt)]
-fn lines_offsets(s: &str) -> Vec<usize> {
-    let mut lines = vec![0];
-    let mut prev = 0;
-    while let Some(len) = s[prev..].find('\n') {
-        prev += len + 1;
-        lines.push(prev);
-    }
-    lines
-}
-
-#[cfg(procmacro2_semver_exempt)]
-struct Codemap {
-    files: Vec<FileInfo>,
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl Codemap {
-    fn next_start_pos(&self) -> u32 {
-        // Add 1 so there's always space between files.
-        //
-        // We'll always have at least 1 file, as we initialize our files list
-        // with a dummy file.
-        self.files.last().unwrap().span.hi + 1
-    }
-
-    fn add_file(&mut self, name: &str, src: &str) -> Span {
-        let lines = lines_offsets(src);
-        let lo = self.next_start_pos();
-        // XXX(nika): Shouild we bother doing a checked cast or checked add here?
-        let span = Span { lo: lo, hi: lo + (src.len() as u32) };
-
-        self.files.push(FileInfo {
-            name: name.to_owned(),
-            span: span,
-            lines: lines,
-        });
-
-        span
-    }
-
-    fn fileinfo(&self, span: Span) -> &FileInfo {
-        for file in &self.files {
-            if file.span_within(span) {
-                return file;
-            }
-        }
-        panic!("Invalid span with no related FileInfo!");
-    }
-}
-
-#[derive(Clone, Copy, Debug)]
-pub struct Span {
-    #[cfg(procmacro2_semver_exempt)]
-    lo: u32,
-    #[cfg(procmacro2_semver_exempt)]
-    hi: u32,
-}
-
-impl Span {
-    #[cfg(not(procmacro2_semver_exempt))]
-    pub fn call_site() -> Span {
-        Span {}
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn call_site() -> Span {
-        Span { lo: 0, hi: 0 }
-    }
-
-    pub fn def_site() -> Span {
-        Span::call_site()
-    }
-
-    pub fn resolved_at(&self, _other: Span) -> Span {
-        // Stable spans consist only of line/column information, so
-        // `resolved_at` and `located_at` only select which span the
-        // caller wants line/column information from.
-        *self
-    }
-
-    pub fn located_at(&self, other: Span) -> Span {
-        other
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn source_file(&self) -> SourceFile {
-        CODEMAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            SourceFile {
-                name: FileName(fi.name.clone()),
-            }
-        })
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn start(&self) -> LineColumn {
-        CODEMAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            fi.offset_line_column(self.lo as usize)
-        })
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn end(&self) -> LineColumn {
-        CODEMAP.with(|cm| {
-            let cm = cm.borrow();
-            let fi = cm.fileinfo(*self);
-            fi.offset_line_column(self.hi as usize)
-        })
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn join(&self, other: Span) -> Option<Span> {
-        CODEMAP.with(|cm| {
-            let cm = cm.borrow();
-            // If `other` is not within the same FileInfo as us, return None.
-            if !cm.fileinfo(*self).span_within(other) {
-                return None;
-            }
-            Some(Span {
-                lo: cmp::min(self.lo, other.lo),
-                hi: cmp::max(self.hi, other.hi),
-            })
-        })
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct Term {
-    intern: usize,
-    not_send_sync: PhantomData<*const ()>,
-}
-
-thread_local!(static SYMBOLS: RefCell<Interner> = RefCell::new(Interner::new()));
-
-impl Term {
-    pub fn intern(string: &str) -> Term {
-        Term {
-            intern: SYMBOLS.with(|s| s.borrow_mut().intern(string)),
-            not_send_sync: PhantomData,
-        }
-    }
-
-    pub fn as_str(&self) -> &str {
-        SYMBOLS.with(|interner| {
-            let interner = interner.borrow();
-            let s = interner.get(self.intern);
-            unsafe {
-                &*(s as *const str)
-            }
-        })
-    }
-}
-
-impl fmt::Debug for Term {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Term").field(&self.as_str()).finish()
-    }
-}
-
-struct Interner {
-    string_to_index: HashMap<MyRc, usize>,
-    index_to_string: Vec<Rc<String>>,
-}
-
-#[derive(Hash, Eq, PartialEq)]
-struct MyRc(Rc<String>);
-
-impl Borrow<str> for MyRc {
-    fn borrow(&self) -> &str {
-        &self.0
-    }
-}
-
-impl Interner {
-    fn new() -> Interner {
-        Interner {
-            string_to_index: HashMap::new(),
-            index_to_string: Vec::new(),
-        }
-    }
-
-   fn intern(&mut self, s: &str) -> usize {
-        if let Some(&idx) = self.string_to_index.get(s) {
-            return idx
-        }
-        let s = Rc::new(s.to_string());
-        self.index_to_string.push(s.clone());
-        self.string_to_index.insert(MyRc(s), self.index_to_string.len() - 1);
-        self.index_to_string.len() - 1
-    }
-
-   fn get(&self, idx: usize) -> &str {
-       &self.index_to_string[idx]
-   }
-}
-
-#[derive(Clone, Debug)]
-pub struct Literal(String);
-
-impl Literal {
-    pub fn byte_char(byte: u8) -> Literal {
-        match byte {
-            0 => Literal(format!("b'\\0'")),
-            b'\"' => Literal(format!("b'\"'")),
-            n => {
-                let mut escaped = "b'".to_string();
-                escaped.extend(ascii::escape_default(n).map(|c| c as char));
-                escaped.push('\'');
-                Literal(escaped)
-            }
-        }
-    }
-
-    pub fn byte_string(bytes: &[u8]) -> Literal {
-        let mut escaped = "b\"".to_string();
-        for b in bytes {
-            match *b {
-                b'\0' => escaped.push_str(r"\0"),
-                b'\t' => escaped.push_str(r"\t"),
-                b'\n' => escaped.push_str(r"\n"),
-                b'\r' => escaped.push_str(r"\r"),
-                b'"' => escaped.push_str("\\\""),
-                b'\\' => escaped.push_str("\\\\"),
-                b'\x20' ... b'\x7E' => escaped.push(*b as char),
-                _ => escaped.push_str(&format!("\\x{:02X}", b)),
-            }
-        }
-        escaped.push('"');
-        Literal(escaped)
-    }
-
-    pub fn doccomment(s: &str) -> Literal {
-        Literal(s.to_string())
-    }
-
-    pub fn float(n: f64) -> Literal {
-        if !n.is_finite() {
-            panic!("Invalid float literal {}", n);
-        }
-        let mut s = n.to_string();
-        if !s.contains('.') {
-            s += ".0";
-        }
-        Literal(s)
-    }
-
-    pub fn integer(s: i64) -> Literal {
-        Literal(s.to_string())
-    }
-
-    pub fn raw_string(s: &str, pounds: usize) -> Literal {
-        let mut ret = format!("r");
-        ret.extend((0..pounds).map(|_| "#"));
-        ret.push('"');
-        ret.push_str(s);
-        ret.push('"');
-        ret.extend((0..pounds).map(|_| "#"));
-        Literal(ret)
-    }
-
-    pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
-        let mut ret = format!("br");
-        ret.extend((0..pounds).map(|_| "#"));
-        ret.push('"');
-        ret.push_str(s);
-        ret.push('"');
-        ret.extend((0..pounds).map(|_| "#"));
-        Literal(ret)
-    }
-}
-
-impl fmt::Display for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-macro_rules! ints {
-    ($($t:ty,)*) => {$(
-        impl From<$t> for Literal {
-            fn from(t: $t) -> Literal {
-                Literal(format!(concat!("{}", stringify!($t)), t))
-            }
-        }
-    )*}
-}
-
-ints! {
-    u8, u16, u32, u64, usize,
-    i8, i16, i32, i64, isize,
-}
-
-macro_rules! floats {
-    ($($t:ty,)*) => {$(
-        impl From<$t> for Literal {
-            fn from(t: $t) -> Literal {
-                assert!(!t.is_nan());
-                assert!(!t.is_infinite());
-                Literal(format!(concat!("{}", stringify!($t)), t))
-            }
-        }
-    )*}
-}
-
-floats! {
-    f32, f64,
-}
-
-impl<'a> From<&'a str> for Literal {
-    fn from(t: &'a str) -> Literal {
-        let mut s = t.chars().flat_map(|c| c.escape_default()).collect::<String>();
-        s.push('"');
-        s.insert(0, '"');
-        Literal(s)
-    }
-}
-
-impl From<char> for Literal {
-    fn from(t: char) -> Literal {
-        Literal(format!("'{}'", t.escape_default().collect::<String>()))
-    }
-}
-
-named!(token_stream -> ::TokenStream, map!(
-    many0!(token_tree),
-    |trees| ::TokenStream(TokenStream { inner: trees })
-));
-
-#[cfg(not(procmacro2_semver_exempt))]
-fn token_tree(input: Cursor) -> PResult<TokenTree> {
-    let (input, kind) = token_kind(input)?;
-    Ok((input, TokenTree {
-        span: ::Span(Span {}),
-        kind: kind,
-    }))
-}
-
-#[cfg(procmacro2_semver_exempt)]
-fn token_tree(input: Cursor) -> PResult<TokenTree> {
-    let input = skip_whitespace(input);
-    let lo = input.off;
-    let (input, kind) = token_kind(input)?;
-    let hi = input.off;
-    Ok((input, TokenTree {
-        span: ::Span(Span {
-            lo: lo,
-            hi: hi,
-        }),
-        kind: kind,
-    }))
-}
-
-named!(token_kind -> TokenNode, alt!(
-    map!(delimited, |(d, s)| TokenNode::Group(d, s))
-    |
-    map!(literal, TokenNode::Literal) // must be before symbol
-    |
-    symbol
-    |
-    map!(op, |(op, kind)| TokenNode::Op(op, kind))
-));
-
-named!(delimited -> (Delimiter, ::TokenStream), alt!(
-    delimited!(
-        punct!("("),
-        token_stream,
-        punct!(")")
-    ) => { |ts| (Delimiter::Parenthesis, ts) }
-    |
-    delimited!(
-        punct!("["),
-        token_stream,
-        punct!("]")
-    ) => { |ts| (Delimiter::Bracket, ts) }
-    |
-    delimited!(
-        punct!("{"),
-        token_stream,
-        punct!("}")
-    ) => { |ts| (Delimiter::Brace, ts) }
-));
-
-fn symbol(mut input: Cursor) -> PResult<TokenNode> {
-    input = skip_whitespace(input);
-
-    let mut chars = input.char_indices();
-
-    let lifetime = input.starts_with("'");
-    if lifetime {
-        chars.next();
-    }
-
-    match chars.next() {
-        Some((_, ch)) if UnicodeXID::is_xid_start(ch) || ch == '_' => {}
-        _ => return Err(LexError),
-    }
-
-    let mut end = input.len();
-    for (i, ch) in chars {
-        if !UnicodeXID::is_xid_continue(ch) {
-            end = i;
-            break;
-        }
-    }
-
-    if lifetime && &input.rest[..end] != "'static" && KEYWORDS.contains(&&input.rest[1..end]) {
-        Err(LexError)
-    } else {
-        let a = &input.rest[..end];
-        if a == "_" {
-            Ok((input.advance(end), TokenNode::Op('_', Spacing::Alone)))
-        } else {
-            Ok((input.advance(end), TokenNode::Term(::Term::intern(a))))
-        }
-    }
-}
-
-// From https://github.com/rust-lang/rust/blob/master/src/libsyntax_pos/symbol.rs
-static KEYWORDS: &'static [&'static str] = &[
-    "abstract", "alignof", "as", "become", "box", "break", "const", "continue",
-    "crate", "do", "else", "enum", "extern", "false", "final", "fn", "for",
-    "if", "impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut",
-    "offsetof", "override", "priv", "proc", "pub", "pure", "ref", "return",
-    "self", "Self", "sizeof", "static", "struct", "super", "trait", "true",
-    "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while",
-    "yield",
-];
-
-fn literal(input: Cursor) -> PResult<::Literal> {
-    let input_no_ws = skip_whitespace(input);
-
-    match literal_nocapture(input_no_ws) {
-        Ok((a, ())) => {
-            let start = input.len() - input_no_ws.len();
-            let len = input_no_ws.len() - a.len();
-            let end = start + len;
-            Ok((a, ::Literal(Literal(input.rest[start..end].to_string()))))
-        }
-        Err(LexError) => Err(LexError),
-    }
-}
-
-named!(literal_nocapture -> (), alt!(
-    string
-    |
-    byte_string
-    |
-    byte
-    |
-    character
-    |
-    float
-    |
-    int
-    |
-    doc_comment
-));
-
-named!(string -> (), alt!(
-    quoted_string
-    |
-    preceded!(
-        punct!("r"),
-        raw_string
-    ) => { |_| () }
-));
-
-named!(quoted_string -> (), delimited!(
-    punct!("\""),
-    cooked_string,
-    tag!("\"")
-));
-
-fn cooked_string(input: Cursor) -> PResult<()> {
-    let mut chars = input.char_indices().peekable();
-    while let Some((byte_offset, ch)) = chars.next() {
-        match ch {
-            '"' => {
-                return Ok((input.advance(byte_offset), ()));
-            }
-            '\r' => {
-                if let Some((_, '\n')) = chars.next() {
-                    // ...
-                } else {
-                    break;
-                }
-            }
-            '\\' => {
-                match chars.next() {
-                    Some((_, 'x')) => {
-                        if !backslash_x_char(&mut chars) {
-                            break
-                        }
-                    }
-                    Some((_, 'n')) |
-                    Some((_, 'r')) |
-                    Some((_, 't')) |
-                    Some((_, '\\')) |
-                    Some((_, '\'')) |
-                    Some((_, '"')) |
-                    Some((_, '0')) => {}
-                    Some((_, 'u')) => {
-                        if !backslash_u(&mut chars) {
-                            break
-                        }
-                    }
-                    Some((_, '\n')) | Some((_, '\r')) => {
-                        while let Some(&(_, ch)) = chars.peek() {
-                            if ch.is_whitespace() {
-                                chars.next();
-                            } else {
-                                break;
-                            }
-                        }
-                    }
-                    _ => break,
-                }
-            }
-            _ch => {}
-        }
-    }
-    Err(LexError)
-}
-
-named!(byte_string -> (), alt!(
-    delimited!(
-        punct!("b\""),
-        cooked_byte_string,
-        tag!("\"")
-    ) => { |_| () }
-    |
-    preceded!(
-        punct!("br"),
-        raw_string
-    ) => { |_| () }
-));
-
-fn cooked_byte_string(mut input: Cursor) -> PResult<()> {
-    let mut bytes = input.bytes().enumerate();
-    'outer: while let Some((offset, b)) = bytes.next() {
-        match b {
-            b'"' => {
-                return Ok((input.advance(offset), ()));
-            }
-            b'\r' => {
-                if let Some((_, b'\n')) = bytes.next() {
-                    // ...
-                } else {
-                    break;
-                }
-            }
-            b'\\' => {
-                match bytes.next() {
-                    Some((_, b'x')) => {
-                        if !backslash_x_byte(&mut bytes) {
-                            break
-                        }
-                    }
-                    Some((_, b'n')) |
-                    Some((_, b'r')) |
-                    Some((_, b't')) |
-                    Some((_, b'\\')) |
-                    Some((_, b'0')) |
-                    Some((_, b'\'')) |
-                    Some((_, b'"'))  => {}
-                    Some((newline, b'\n')) |
-                    Some((newline, b'\r')) => {
-                        let rest = input.advance(newline + 1);
-                        for (offset, ch) in rest.char_indices() {
-                            if !ch.is_whitespace() {
-                                input = rest.advance(offset);
-                                bytes = input.bytes().enumerate();
-                                continue 'outer;
-                            }
-                        }
-                        break;
-                    }
-                    _ => break,
-                }
-            }
-            b if b < 0x80 => {}
-            _ => break,
-        }
-    }
-    Err(LexError)
-}
-
-fn raw_string(input: Cursor) -> PResult<()> {
-    let mut chars = input.char_indices();
-    let mut n = 0;
-    while let Some((byte_offset, ch)) = chars.next() {
-        match ch {
-            '"' => {
-                n = byte_offset;
-                break;
-            }
-            '#' => {}
-            _ => return Err(LexError),
-        }
-    }
-    for (byte_offset, ch) in chars {
-        match ch {
-            '"' if input.advance(byte_offset + 1).starts_with(&input.rest[..n]) => {
-                let rest = input.advance(byte_offset + 1 + n);
-                return Ok((rest, ()))
-            }
-            '\r' => {}
-            _ => {}
-        }
-    }
-    Err(LexError)
-}
-
-named!(byte -> (), do_parse!(
-    punct!("b") >>
-    tag!("'") >>
-    cooked_byte >>
-    tag!("'") >>
-    (())
-));
-
-fn cooked_byte(input: Cursor) -> PResult<()> {
-    let mut bytes = input.bytes().enumerate();
-    let ok = match bytes.next().map(|(_, b)| b) {
-        Some(b'\\') => {
-            match bytes.next().map(|(_, b)| b) {
-                Some(b'x') => backslash_x_byte(&mut bytes),
-                Some(b'n') |
-                Some(b'r') |
-                Some(b't') |
-                Some(b'\\') |
-                Some(b'0') |
-                Some(b'\'') |
-                Some(b'"') => true,
-                _ => false,
-            }
-        }
-        b => b.is_some(),
-    };
-    if ok {
-        match bytes.next() {
-            Some((offset, _)) => {
-                if input.chars().as_str().is_char_boundary(offset) {
-                    Ok((input.advance(offset), ()))
-                } else {
-                    Err(LexError)
-                }
-            }
-            None => Ok((input.advance(input.len()), ())),
-        }
-    } else {
-        Err(LexError)
-    }
-}
-
-named!(character -> (), do_parse!(
-    punct!("'") >>
-    cooked_char >>
-    tag!("'") >>
-    (())
-));
-
-fn cooked_char(input: Cursor) -> PResult<()> {
-    let mut chars = input.char_indices();
-    let ok = match chars.next().map(|(_, ch)| ch) {
-        Some('\\') => {
-            match chars.next().map(|(_, ch)| ch) {
-                Some('x') => backslash_x_char(&mut chars),
-                Some('u') => backslash_u(&mut chars),
-                Some('n') |
-                Some('r') |
-                Some('t') |
-                Some('\\') |
-                Some('0') |
-                Some('\'') |
-                Some('"') => true,
-                _ => false,
-            }
-        }
-        ch => ch.is_some(),
-    };
-    if ok {
-        match chars.next() {
-            Some((idx, _)) => Ok((input.advance(idx), ())),
-            None => Ok((input.advance(input.len()), ())),
-        }
-    } else {
-        Err(LexError)
-    }
-}
-
-macro_rules! next_ch {
-    ($chars:ident @ $pat:pat $(| $rest:pat)*) => {
-        match $chars.next() {
-            Some((_, ch)) => match ch {
-                $pat $(| $rest)*  => ch,
-                _ => return false,
-            },
-            None => return false
-        }
-    };
-}
-
-fn backslash_x_char<I>(chars: &mut I) -> bool
-    where I: Iterator<Item = (usize, char)>
-{
-    next_ch!(chars @ '0'...'7');
-    next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
-    true
-}
-
-fn backslash_x_byte<I>(chars: &mut I) -> bool
-    where I: Iterator<Item = (usize, u8)>
-{
-    next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
-    next_ch!(chars @ b'0'...b'9' | b'a'...b'f' | b'A'...b'F');
-    true
-}
-
-fn backslash_u<I>(chars: &mut I) -> bool
-    where I: Iterator<Item = (usize, char)>
-{
-    next_ch!(chars @ '{');
-    next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F');
-    loop {
-        let c = next_ch!(chars @ '0'...'9' | 'a'...'f' | 'A'...'F' | '_' | '}');
-        if c == '}' {
-            return true;
-        }
-    }
-}
-
-fn float(input: Cursor) -> PResult<()> {
-    let (rest, ()) = float_digits(input)?;
-    for suffix in &["f32", "f64"] {
-        if rest.starts_with(suffix) {
-            return word_break(rest.advance(suffix.len()));
-        }
-    }
-    word_break(rest)
-}
-
-fn float_digits(input: Cursor) -> PResult<()> {
-    let mut chars = input.chars().peekable();
-    match chars.next() {
-        Some(ch) if ch >= '0' && ch <= '9' => {}
-        _ => return Err(LexError),
-    }
-
-    let mut len = 1;
-    let mut has_dot = false;
-    let mut has_exp = false;
-    while let Some(&ch) = chars.peek() {
-        match ch {
-            '0'...'9' | '_' => {
-                chars.next();
-                len += 1;
-            }
-            '.' => {
-                if has_dot {
-                    break;
-                }
-                chars.next();
-                if chars.peek()
-                       .map(|&ch| ch == '.' || UnicodeXID::is_xid_start(ch))
-                       .unwrap_or(false) {
-                    return Err(LexError);
-                }
-                len += 1;
-                has_dot = true;
-            }
-            'e' | 'E' => {
-                chars.next();
-                len += 1;
-                has_exp = true;
-                break;
-            }
-            _ => break,
-        }
-    }
-
-    let rest = input.advance(len);
-    if !(has_dot || has_exp || rest.starts_with("f32") || rest.starts_with("f64")) {
-        return Err(LexError);
-    }
-
-    if has_exp {
-        let mut has_exp_value = false;
-        while let Some(&ch) = chars.peek() {
-            match ch {
-                '+' | '-' => {
-                    if has_exp_value {
-                        break;
-                    }
-                    chars.next();
-                    len += 1;
-                }
-                '0'...'9' => {
-                    chars.next();
-                    len += 1;
-                    has_exp_value = true;
-                }
-                '_' => {
-                    chars.next();
-                    len += 1;
-                }
-                _ => break,
-            }
-        }
-        if !has_exp_value {
-            return Err(LexError);
-        }
-    }
-
-    Ok((input.advance(len), ()))
-}
-
-fn int(input: Cursor) -> PResult<()> {
-    let (rest, ()) = digits(input)?;
-    for suffix in &[
-        "isize",
-        "i8",
-        "i16",
-        "i32",
-        "i64",
-        "i128",
-        "usize",
-        "u8",
-        "u16",
-        "u32",
-        "u64",
-        "u128",
-    ] {
-        if rest.starts_with(suffix) {
-            return word_break(rest.advance(suffix.len()));
-        }
-    }
-    word_break(rest)
-}
-
-fn digits(mut input: Cursor) -> PResult<()> {
-    let base = if input.starts_with("0x") {
-        input = input.advance(2);
-        16
-    } else if input.starts_with("0o") {
-        input = input.advance(2);
-        8
-    } else if input.starts_with("0b") {
-        input = input.advance(2);
-        2
-    } else {
-        10
-    };
-
-    let mut len = 0;
-    let mut empty = true;
-    for b in input.bytes() {
-        let digit = match b {
-            b'0'...b'9' => (b - b'0') as u64,
-            b'a'...b'f' => 10 + (b - b'a') as u64,
-            b'A'...b'F' => 10 + (b - b'A') as u64,
-            b'_' => {
-                if empty && base == 10 {
-                    return Err(LexError);
-                }
-                len += 1;
-                continue;
-            }
-            _ => break,
-        };
-        if digit >= base {
-            return Err(LexError);
-        }
-        len += 1;
-        empty = false;
-    }
-    if empty {
-        Err(LexError)
-    } else {
-        Ok((input.advance(len), ()))
-    }
-}
-
-fn op(input: Cursor) -> PResult<(char, Spacing)> {
-    let input = skip_whitespace(input);
-    match op_char(input) {
-        Ok((rest, ch)) => {
-            let kind = match op_char(rest) {
-                Ok(_) => Spacing::Joint,
-                Err(LexError) => Spacing::Alone,
-            };
-            Ok((rest, (ch, kind)))
-        }
-        Err(LexError) => Err(LexError),
-    }
-}
-
-fn op_char(input: Cursor) -> PResult<char> {
-    let mut chars = input.chars();
-    let first = match chars.next() {
-        Some(ch) => ch,
-        None => {
-            return Err(LexError);
-        }
-    };
-    let recognized = "~!@#$%^&*-=+|;:,<.>/?";
-    if recognized.contains(first) {
-        Ok((input.advance(first.len_utf8()), first))
-    } else {
-        Err(LexError)
-    }
-}
-
-named!(doc_comment -> (), alt!(
-    do_parse!(
-        punct!("//!") >>
-        take_until!("\n") >>
-        (())
-    )
-    |
-    do_parse!(
-        option!(whitespace) >>
-        peek!(tag!("/*!")) >>
-        block_comment >>
-        (())
-    )
-    |
-    do_parse!(
-        punct!("///") >>
-        not!(tag!("/")) >>
-        take_until!("\n") >>
-        (())
-    )
-    |
-    do_parse!(
-        option!(whitespace) >>
-        peek!(tuple!(tag!("/**"), not!(tag!("*")))) >>
-        block_comment >>
-        (())
-    )
-));
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/src/strnom.rs
+++ /dev/null
@@ -1,447 +0,0 @@
-//! Adapted from [`nom`](https://github.com/Geal/nom).
-
-use std::str::{Chars, CharIndices, Bytes};
-
-use unicode_xid::UnicodeXID;
-
-use imp::LexError;
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Cursor<'a> {
-    pub rest: &'a str,
-    #[cfg(procmacro2_semver_exempt)]
-    pub off: u32,
-}
-
-impl<'a> Cursor<'a> {
-    #[cfg(not(procmacro2_semver_exempt))]
-    pub fn advance(&self, amt: usize) -> Cursor<'a> {
-        Cursor {
-            rest: &self.rest[amt..],
-        }
-    }
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn advance(&self, amt: usize) -> Cursor<'a> {
-        Cursor {
-            rest: &self.rest[amt..],
-            off: self.off + (amt as u32),
-        }
-    }
-
-    pub fn find(&self, p: char) -> Option<usize> {
-        self.rest.find(p)
-    }
-
-    pub fn starts_with(&self, s: &str) -> bool {
-        self.rest.starts_with(s)
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.rest.is_empty()
-    }
-
-    pub fn len(&self) -> usize {
-        self.rest.len()
-    }
-
-    pub fn as_bytes(&self) -> &'a [u8] {
-        self.rest.as_bytes()
-    }
-
-    pub fn bytes(&self) -> Bytes<'a> {
-        self.rest.bytes()
-    }
-
-    pub fn chars(&self) -> Chars<'a> {
-        self.rest.chars()
-    }
-
-    pub fn char_indices(&self) -> CharIndices<'a> {
-        self.rest.char_indices()
-    }
-}
-
-pub type PResult<'a, O> = Result<(Cursor<'a>, O), LexError>;
-
-pub fn whitespace(input: Cursor) -> PResult<()> {
-    if input.is_empty() {
-        return Err(LexError);
-    }
-
-    let bytes = input.as_bytes();
-    let mut i = 0;
-    while i < bytes.len() {
-        let s = input.advance(i);
-        if bytes[i] == b'/' {
-            if s.starts_with("//") && (!s.starts_with("///") || s.starts_with("////")) &&
-               !s.starts_with("//!") {
-                if let Some(len) = s.find('\n') {
-                    i += len + 1;
-                    continue;
-                }
-                break;
-            } else if s.starts_with("/**/") {
-                i += 4;
-                continue
-            } else if s.starts_with("/*") && (!s.starts_with("/**") || s.starts_with("/***")) &&
-                      !s.starts_with("/*!") {
-                let (_, com) = block_comment(s)?;
-                i += com.len();
-                continue;
-            }
-        }
-        match bytes[i] {
-            b' ' | 0x09...0x0d => {
-                i += 1;
-                continue;
-            }
-            b if b <= 0x7f => {}
-            _ => {
-                let ch = s.chars().next().unwrap();
-                if is_whitespace(ch) {
-                    i += ch.len_utf8();
-                    continue;
-                }
-            }
-        }
-        return if i > 0 {
-            Ok((s, ()))
-        } else {
-            Err(LexError)
-        };
-    }
-    Ok((input.advance(input.len()), ()))
-}
-
-pub fn block_comment(input: Cursor) -> PResult<&str> {
-    if !input.starts_with("/*") {
-        return Err(LexError);
-    }
-
-    let mut depth = 0;
-    let bytes = input.as_bytes();
-    let mut i = 0;
-    let upper = bytes.len() - 1;
-    while i < upper {
-        if bytes[i] == b'/' && bytes[i + 1] == b'*' {
-            depth += 1;
-            i += 1; // eat '*'
-        } else if bytes[i] == b'*' && bytes[i + 1] == b'/' {
-            depth -= 1;
-            if depth == 0 {
-                return Ok((input.advance(i + 2), &input.rest[..i + 2]));
-            }
-            i += 1; // eat '/'
-        }
-        i += 1;
-    }
-    Err(LexError)
-}
-
-pub fn skip_whitespace(input: Cursor) -> Cursor {
-    match whitespace(input) {
-        Ok((rest, _)) => rest,
-        Err(LexError) => input,
-    }
-}
-
-fn is_whitespace(ch: char) -> bool {
-    // Rust treats left-to-right mark and right-to-left mark as whitespace
-    ch.is_whitespace() || ch == '\u{200e}' || ch == '\u{200f}'
-}
-
-pub fn word_break(input: Cursor) -> PResult<()> {
-    match input.chars().next() {
-        Some(ch) if UnicodeXID::is_xid_continue(ch) => Err(LexError),
-        Some(_) | None => Ok((input, ())),
-    }
-}
-
-macro_rules! named {
-    ($name:ident -> $o:ty, $submac:ident!( $($args:tt)* )) => {
-        fn $name<'a>(i: Cursor<'a>) -> $crate::strnom::PResult<'a, $o> {
-            $submac!(i, $($args)*)
-        }
-    };
-}
-
-macro_rules! alt {
-    ($i:expr, $e:ident | $($rest:tt)*) => {
-        alt!($i, call!($e) | $($rest)*)
-    };
-
-    ($i:expr, $subrule:ident!( $($args:tt)*) | $($rest:tt)*) => {
-        match $subrule!($i, $($args)*) {
-            res @ Ok(_) => res,
-            _ => alt!($i, $($rest)*)
-        }
-    };
-
-    ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr } | $($rest:tt)+) => {
-        match $subrule!($i, $($args)*) {
-            Ok((i, o)) => Ok((i, $gen(o))),
-            Err(LexError) => alt!($i, $($rest)*)
-        }
-    };
-
-    ($i:expr, $e:ident => { $gen:expr } | $($rest:tt)*) => {
-        alt!($i, call!($e) => { $gen } | $($rest)*)
-    };
-
-    ($i:expr, $e:ident => { $gen:expr }) => {
-        alt!($i, call!($e) => { $gen })
-    };
-
-    ($i:expr, $subrule:ident!( $($args:tt)* ) => { $gen:expr }) => {
-        match $subrule!($i, $($args)*) {
-            Ok((i, o)) => Ok((i, $gen(o))),
-            Err(LexError) => Err(LexError),
-        }
-    };
-
-    ($i:expr, $e:ident) => {
-        alt!($i, call!($e))
-    };
-
-    ($i:expr, $subrule:ident!( $($args:tt)*)) => {
-        $subrule!($i, $($args)*)
-    };
-}
-
-macro_rules! do_parse {
-    ($i:expr, ( $($rest:expr),* )) => {
-        Ok(($i, ( $($rest),* )))
-    };
-
-    ($i:expr, $e:ident >> $($rest:tt)*) => {
-        do_parse!($i, call!($e) >> $($rest)*)
-    };
-
-    ($i:expr, $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, _)) => do_parse!(i, $($rest)*),
-        }
-    };
-
-    ($i:expr, $field:ident : $e:ident >> $($rest:tt)*) => {
-        do_parse!($i, $field: call!($e) >> $($rest)*)
-    };
-
-    ($i:expr, $field:ident : $submac:ident!( $($args:tt)* ) >> $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => {
-                let $field = o;
-                do_parse!(i, $($rest)*)
-            },
-        }
-    };
-}
-
-macro_rules! peek {
-    ($i:expr, $submac:ident!( $($args:tt)* )) => {
-        match $submac!($i, $($args)*) {
-            Ok((_, o)) => Ok(($i, o)),
-            Err(LexError) => Err(LexError),
-        }
-    };
-}
-
-macro_rules! call {
-    ($i:expr, $fun:expr $(, $args:expr)*) => {
-        $fun($i $(, $args)*)
-    };
-}
-
-macro_rules! option {
-    ($i:expr, $f:expr) => {
-        match $f($i) {
-            Ok((i, o)) => Ok((i, Some(o))),
-            Err(LexError) => Ok(($i, None)),
-        }
-    };
-}
-
-macro_rules! take_until {
-    ($i:expr, $substr:expr) => {{
-        if $substr.len() > $i.len() {
-            Err(LexError)
-        } else {
-            let substr_vec: Vec<char> = $substr.chars().collect();
-            let mut window: Vec<char> = vec![];
-            let mut offset = $i.len();
-            let mut parsed = false;
-            for (o, c) in $i.char_indices() {
-                window.push(c);
-                if window.len() > substr_vec.len() {
-                    window.remove(0);
-                }
-                if window == substr_vec {
-                    parsed = true;
-                    window.pop();
-                    let window_len: usize = window.iter()
-                        .map(|x| x.len_utf8())
-                        .fold(0, |x, y| x + y);
-                    offset = o - window_len;
-                    break;
-                }
-            }
-            if parsed {
-                Ok(($i.advance(offset), &$i.rest[..offset]))
-            } else {
-                Err(LexError)
-            }
-        }
-    }};
-}
-
-macro_rules! tuple {
-    ($i:expr, $($rest:tt)*) => {
-        tuple_parser!($i, (), $($rest)*)
-    };
-}
-
-/// Do not use directly. Use `tuple!`.
-macro_rules! tuple_parser {
-    ($i:expr, ($($parsed:tt),*), $e:ident, $($rest:tt)*) => {
-        tuple_parser!($i, ($($parsed),*), call!($e), $($rest)*)
-    };
-
-    ($i:expr, (), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => tuple_parser!(i, (o), $($rest)*),
-        }
-    };
-
-    ($i:expr, ($($parsed:tt)*), $submac:ident!( $($args:tt)* ), $($rest:tt)*) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => tuple_parser!(i, ($($parsed)* , o), $($rest)*),
-        }
-    };
-
-    ($i:expr, ($($parsed:tt),*), $e:ident) => {
-        tuple_parser!($i, ($($parsed),*), call!($e))
-    };
-
-    ($i:expr, (), $submac:ident!( $($args:tt)* )) => {
-        $submac!($i, $($args)*)
-    };
-
-    ($i:expr, ($($parsed:expr),*), $submac:ident!( $($args:tt)* )) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => Ok((i, ($($parsed),*, o)))
-        }
-    };
-
-    ($i:expr, ($($parsed:expr),*)) => {
-        Ok(($i, ($($parsed),*)))
-    };
-}
-
-macro_rules! not {
-    ($i:expr, $submac:ident!( $($args:tt)* )) => {
-        match $submac!($i, $($args)*) {
-            Ok((_, _)) => Err(LexError),
-            Err(LexError) => Ok(($i, ())),
-        }
-    };
-}
-
-macro_rules! tag {
-    ($i:expr, $tag:expr) => {
-        if $i.starts_with($tag) {
-            Ok(($i.advance($tag.len()), &$i.rest[..$tag.len()]))
-        } else {
-            Err(LexError)
-        }
-    };
-}
-
-macro_rules! punct {
-    ($i:expr, $punct:expr) => {
-        $crate::strnom::punct($i, $punct)
-    };
-}
-
-/// Do not use directly. Use `punct!`.
-pub fn punct<'a>(input: Cursor<'a>, token: &'static str) -> PResult<'a, &'a str> {
-    let input = skip_whitespace(input);
-    if input.starts_with(token) {
-        Ok((input.advance(token.len()), token))
-    } else {
-        Err(LexError)
-    }
-}
-
-macro_rules! preceded {
-    ($i:expr, $submac:ident!( $($args:tt)* ), $submac2:ident!( $($args2:tt)* )) => {
-        match tuple!($i, $submac!($($args)*), $submac2!($($args2)*)) {
-            Ok((remaining, (_, o))) => Ok((remaining, o)),
-            Err(LexError) => Err(LexError),
-        }
-    };
-
-    ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
-        preceded!($i, $submac!($($args)*), call!($g))
-    };
-}
-
-macro_rules! delimited {
-    ($i:expr, $submac:ident!( $($args:tt)* ), $($rest:tt)+) => {
-        match tuple_parser!($i, (), $submac!($($args)*), $($rest)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i1, (_, o, _))) => Ok((i1, o))
-        }
-    };
-}
-
-macro_rules! map {
-    ($i:expr, $submac:ident!( $($args:tt)* ), $g:expr) => {
-        match $submac!($i, $($args)*) {
-            Err(LexError) => Err(LexError),
-            Ok((i, o)) => Ok((i, call!(o, $g)))
-        }
-    };
-
-    ($i:expr, $f:expr, $g:expr) => {
-        map!($i, call!($f), $g)
-    };
-}
-
-macro_rules! many0 {
-    ($i:expr, $f:expr) => {{
-        let ret;
-        let mut res   = ::std::vec::Vec::new();
-        let mut input = $i;
-
-        loop {
-            if input.is_empty() {
-                ret = Ok((input, res));
-                break;
-            }
-
-            match $f(input) {
-                Err(LexError) => {
-                    ret = Ok((input, res));
-                    break;
-                }
-                Ok((i, o)) => {
-                    // loop trip must always consume (otherwise infinite loops)
-                    if i.len() == input.len() {
-                        ret = Err(LexError);
-                        break;
-                    }
-
-                    res.push(o);
-                    input = i;
-                }
-            }
-        }
-
-        ret
-    }};
-}
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/src/unstable.rs
+++ /dev/null
@@ -1,406 +0,0 @@
-use std::ascii;
-use std::fmt;
-use std::iter;
-use std::str::FromStr;
-
-use proc_macro;
-
-use {TokenTree, TokenNode, Delimiter, Spacing};
-
-#[derive(Clone)]
-pub struct TokenStream(proc_macro::TokenStream);
-
-pub struct LexError(proc_macro::LexError);
-
-impl TokenStream {
-    pub fn empty() -> TokenStream {
-        TokenStream(proc_macro::TokenStream::empty())
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-}
-
-impl FromStr for TokenStream {
-    type Err = LexError;
-
-    fn from_str(src: &str) -> Result<TokenStream, LexError> {
-        Ok(TokenStream(src.parse().map_err(LexError)?))
-    }
-}
-
-impl fmt::Display for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl From<proc_macro::TokenStream> for TokenStream {
-    fn from(inner: proc_macro::TokenStream) -> TokenStream {
-        TokenStream(inner)
-    }
-}
-
-impl From<TokenStream> for proc_macro::TokenStream {
-    fn from(inner: TokenStream) -> proc_macro::TokenStream {
-        inner.0
-    }
-}
-
-impl From<TokenTree> for TokenStream {
-    fn from(tree: TokenTree) -> TokenStream {
-        TokenStream(proc_macro::TokenTree {
-            span: (tree.span.0).0,
-            kind: match tree.kind {
-                TokenNode::Group(delim, s) => {
-                    let delim = match delim {
-                        Delimiter::Parenthesis => proc_macro::Delimiter::Parenthesis,
-                        Delimiter::Bracket => proc_macro::Delimiter::Bracket,
-                        Delimiter::Brace => proc_macro::Delimiter::Brace,
-                        Delimiter::None => proc_macro::Delimiter::None,
-                    };
-                    proc_macro::TokenNode::Group(delim, (s.0).0)
-                }
-                TokenNode::Op(ch, kind) => {
-                    let kind = match kind {
-                        Spacing::Joint => proc_macro::Spacing::Joint,
-                        Spacing::Alone => proc_macro::Spacing::Alone,
-                    };
-                    proc_macro::TokenNode::Op(ch, kind)
-                }
-                TokenNode::Term(s) => {
-                    proc_macro::TokenNode::Term((s.0).0)
-                }
-                TokenNode::Literal(l) => {
-                    proc_macro::TokenNode::Literal((l.0).0)
-                }
-            },
-        }.into())
-    }
-}
-
-impl iter::FromIterator<TokenStream> for TokenStream {
-    fn from_iter<I: IntoIterator<Item=TokenStream>>(streams: I) -> Self {
-        let streams = streams.into_iter().map(|s| s.0);
-        TokenStream(streams.collect::<proc_macro::TokenStream>())
-    }
-}
-
-impl fmt::Debug for TokenStream {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Debug for LexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-pub struct TokenTreeIter(proc_macro::TokenTreeIter);
-
-impl IntoIterator for TokenStream {
-    type Item = TokenTree;
-    type IntoIter = TokenTreeIter;
-
-    fn into_iter(self) -> TokenTreeIter {
-        TokenTreeIter(self.0.into_iter())
-    }
-}
-
-impl Iterator for TokenTreeIter {
-    type Item = TokenTree;
-
-    fn next(&mut self) -> Option<TokenTree> {
-        let token = match self.0.next() {
-            Some(n) => n,
-            None => return None,
-        };
-        Some(TokenTree {
-            span: ::Span(Span(token.span)),
-            kind: match token.kind {
-                proc_macro::TokenNode::Group(delim, s) => {
-                    let delim = match delim {
-                        proc_macro::Delimiter::Parenthesis => Delimiter::Parenthesis,
-                        proc_macro::Delimiter::Bracket => Delimiter::Bracket,
-                        proc_macro::Delimiter::Brace => Delimiter::Brace,
-                        proc_macro::Delimiter::None => Delimiter::None,
-                    };
-                    TokenNode::Group(delim, ::TokenStream(TokenStream(s)))
-                }
-                proc_macro::TokenNode::Op(ch, kind) => {
-                    let kind = match kind {
-                        proc_macro::Spacing::Joint => Spacing::Joint,
-                        proc_macro::Spacing::Alone => Spacing::Alone,
-                    };
-                    TokenNode::Op(ch, kind)
-                }
-                proc_macro::TokenNode::Term(s) => {
-                    TokenNode::Term(::Term(Term(s)))
-                }
-                proc_macro::TokenNode::Literal(l) => {
-                    TokenNode::Literal(::Literal(Literal(l)))
-                }
-            },
-        })
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.0.size_hint()
-    }
-}
-
-impl fmt::Debug for TokenTreeIter {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("TokenTreeIter").finish()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, PartialEq, Eq)]
-pub struct FileName(String);
-
-#[cfg(procmacro2_semver_exempt)]
-impl fmt::Display for FileName {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-// NOTE: We have to generate our own filename object here because we can't wrap
-// the one provided by proc_macro.
-#[cfg(procmacro2_semver_exempt)]
-#[derive(Clone, PartialEq, Eq)]
-pub struct SourceFile(proc_macro::SourceFile, FileName);
-
-#[cfg(procmacro2_semver_exempt)]
-impl SourceFile {
-    fn new(sf: proc_macro::SourceFile) -> Self {
-        let filename = FileName(sf.path().to_string());
-        SourceFile(sf, filename)
-    }
-
-    /// Get the path to this source file as a string.
-    pub fn path(&self) -> &FileName {
-        &self.1
-    }
-
-    pub fn is_real(&self) -> bool {
-        self.0.is_real()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl AsRef<FileName> for SourceFile {
-    fn as_ref(&self) -> &FileName {
-        self.path()
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-impl fmt::Debug for SourceFile {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-#[cfg(procmacro2_semver_exempt)]
-pub struct LineColumn {
-    pub line: usize,
-    pub column: usize,
-}
-
-#[derive(Copy, Clone)]
-pub struct Span(proc_macro::Span);
-
-impl From<proc_macro::Span> for ::Span {
-    fn from(proc_span: proc_macro::Span) -> ::Span {
-        ::Span(Span(proc_span))
-    }
-}
-
-impl Span {
-    pub fn call_site() -> Span {
-        Span(proc_macro::Span::call_site())
-    }
-
-    pub fn def_site() -> Span {
-        Span(proc_macro::Span::def_site())
-    }
-
-    pub fn resolved_at(&self, other: Span) -> Span {
-        Span(self.0.resolved_at(other.0))
-    }
-
-    pub fn located_at(&self, other: Span) -> Span {
-        Span(self.0.located_at(other.0))
-    }
-
-    pub fn unstable(self) -> proc_macro::Span {
-        self.0
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn source_file(&self) -> SourceFile {
-        SourceFile::new(self.0.source_file())
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn start(&self) -> LineColumn {
-        let proc_macro::LineColumn{ line, column } = self.0.start();
-        LineColumn { line, column }
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn end(&self) -> LineColumn {
-        let proc_macro::LineColumn{ line, column } = self.0.end();
-        LineColumn { line, column }
-    }
-
-    #[cfg(procmacro2_semver_exempt)]
-    pub fn join(&self, other: Span) -> Option<Span> {
-        self.0.join(other.0).map(Span)
-    }
-}
-
-impl fmt::Debug for Span {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-#[derive(Copy, Clone)]
-pub struct Term(proc_macro::Term);
-
-impl Term {
-    pub fn intern(string: &str) -> Term {
-        Term(proc_macro::Term::intern(string))
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-}
-
-impl fmt::Debug for Term {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-#[derive(Clone)]
-pub struct Literal(proc_macro::Literal);
-
-impl Literal {
-    pub fn byte_char(byte: u8) -> Literal {
-        match byte {
-            0 => Literal(to_literal("b'\\0'")),
-            b'\"' => Literal(to_literal("b'\"'")),
-            n => {
-                let mut escaped = "b'".to_string();
-                escaped.extend(ascii::escape_default(n).map(|c| c as char));
-                escaped.push('\'');
-                Literal(to_literal(&escaped))
-            }
-        }
-    }
-
-    pub fn byte_string(bytes: &[u8]) -> Literal {
-        Literal(proc_macro::Literal::byte_string(bytes))
-    }
-
-    pub fn doccomment(s: &str) -> Literal {
-        Literal(to_literal(s))
-    }
-
-    pub fn float(s: f64) -> Literal {
-        Literal(proc_macro::Literal::float(s))
-    }
-
-    pub fn integer(s: i64) -> Literal {
-        Literal(proc_macro::Literal::integer(s.into()))
-    }
-
-    pub fn raw_string(s: &str, pounds: usize) -> Literal {
-        let mut ret = format!("r");
-        ret.extend((0..pounds).map(|_| "#"));
-        ret.push('"');
-        ret.push_str(s);
-        ret.push('"');
-        ret.extend((0..pounds).map(|_| "#"));
-        Literal(to_literal(&ret))
-    }
-
-    pub fn raw_byte_string(s: &str, pounds: usize) -> Literal {
-        let mut ret = format!("br");
-        ret.extend((0..pounds).map(|_| "#"));
-        ret.push('"');
-        ret.push_str(s);
-        ret.push('"');
-        ret.extend((0..pounds).map(|_| "#"));
-        Literal(to_literal(&ret))
-    }
-}
-
-impl fmt::Display for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-impl fmt::Debug for Literal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.0.fmt(f)
-    }
-}
-
-fn to_literal(s: &str) -> proc_macro::Literal {
-    let stream = s.parse::<proc_macro::TokenStream>().unwrap();
-    match stream.into_iter().next().unwrap().kind {
-        proc_macro::TokenNode::Literal(l) => l,
-        _ => unreachable!(),
-    }
-}
-
-macro_rules! ints {
-    ($($t:ident,)*) => {$(
-        impl From<$t> for Literal {
-            fn from(t: $t) -> Literal {
-                Literal(proc_macro::Literal::$t(t))
-            }
-        }
-    )*}
-}
-
-ints! {
-    u8, u16, u32, u64, usize,
-    i8, i16, i32, i64, isize,
-}
-
-macro_rules! floats {
-    ($($t:ident,)*) => {$(
-        impl From<$t> for Literal {
-            fn from(t: $t) -> Literal {
-                Literal(proc_macro::Literal::$t(t))
-            }
-        }
-    )*}
-}
-
-floats! {
-    f32, f64,
-}
-
-impl<'a> From<&'a str> for Literal {
-    fn from(t: &'a str) -> Literal {
-        Literal(proc_macro::Literal::string(t))
-    }
-}
-
-impl From<char> for Literal {
-    fn from(t: char) -> Literal {
-        Literal(proc_macro::Literal::character(t))
-    }
-}
deleted file mode 100644
--- a/third_party/rust/proc-macro2-0.2.2/tests/test.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-extern crate proc_macro2;
-
-use std::str;
-
-use proc_macro2::{Term, Literal, TokenStream};
-
-#[cfg(procmacro2_semver_exempt)]
-use proc_macro2::TokenNode;
-
-#[cfg(procmacro2_semver_exempt)]
-#[cfg(not(feature = "nightly"))]
-use proc_macro2::Span;
-
-#[test]
-fn symbols() {
-    assert_eq!(Term::intern("foo").as_str(), "foo");
-    assert_eq!(Term::intern("bar").as_str(), "bar");
-}
-
-#[test]
-fn literals() {
-    assert_eq!(Literal::string("foo").to_string(), "\"foo\"");
-    assert_eq!(Literal::string("\"").to_string(), "\"\\\"\"");
-    assert_eq!(Literal::float(10.0).to_string(), "10.0");
-}
-
-#[test]
-fn roundtrip() {
-    fn roundtrip(p: &str) {
-        println!("parse: {}", p);
-        let s = p.parse::<TokenStream>().unwrap().to_string();
-        println!("first: {}", s);
-        let s2 = s.to_string().parse::<TokenStream>().unwrap().to_string();
-        assert_eq!(s, s2);
-    }
-    roundtrip("a");
-    roundtrip("<<");
-    roundtrip("<<=");
-    roundtrip("
-        /// a
-        wut
-    ");
-    roundtrip("
-        1
-        1.0
-        1f32
-        2f64
-        1usize
-        4isize
-        4e10
-        1_000
-        1_0i32
-        8u8
-        9
-        0
-        0xffffffffffffffffffffffffffffffff
-    ");
-    roundtrip("'a");
-    roundtrip("'static");
-    roundtrip("'\\u{10__FFFF}'");
-    roundtrip("\"\\u{10_F0FF__}foo\\u{1_0_0_0__}\"");
-}
-
-#[test]
-fn fail() {
-    fn fail(p: &str) {
-        if p.parse::<TokenStream>().is_ok() {
-            panic!("should have failed to parse: {}", p);
-        }
-    }
-    fail("1x");
-    fail("1u80");
-    fail("1f320");
-    fail("' static");
-    fail("'mut");
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[test]
-fn span_test() {
-    fn check_spans(p: &str, mut lines: &[(usize, usize, usize, usize)]) {
-        let ts = p.parse::<TokenStream>().unwrap();
-        check_spans_internal(ts, &mut lines);
-    }
-
-    fn check_spans_internal(
-        ts: TokenStream,
-        lines: &mut &[(usize, usize, usize, usize)],
-    ) {
-        for i in ts {
-            if let Some((&(sline, scol, eline, ecol), rest)) = lines.split_first() {
-                *lines = rest;
-
-                let start = i.span.start();
-                assert_eq!(start.line, sline, "sline did not match for {}", i);
-                assert_eq!(start.column, scol, "scol did not match for {}", i);
-
-                let end = i.span.end();
-                assert_eq!(end.line, eline, "eline did not match for {}", i);
-                assert_eq!(end.column, ecol, "ecol did not match for {}", i);
-
-                match i.kind {
-                    TokenNode::Group(_, stream) =>
-                        check_spans_internal(stream, lines),
-                    _ => {}
-                }
-            }
-        }
-    }
-
-    check_spans("\
-/// This is a document comment
-testing 123
-{
-  testing 234
-}", &[
-    (1, 0, 1, 30),
-    (2, 0, 2, 7),
-    (2, 8, 2, 11),
-    (3, 0, 5, 1),
-    (4, 2, 4, 9),
-    (4, 10, 4, 13),
-]);
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[cfg(not(feature = "nightly"))]
-#[test]
-fn default_span() {
-    let start = Span::call_site().start();
-    assert_eq!(start.line, 1);
-    assert_eq!(start.column, 0);
-    let end = Span::call_site().end();
-    assert_eq!(end.line, 1);
-    assert_eq!(end.column, 0);
-    let source_file = Span::call_site().source_file();
-    assert_eq!(source_file.path().to_string(), "<unspecified>");
-    assert!(!source_file.is_real());
-}
-
-#[cfg(procmacro2_semver_exempt)]
-#[test]
-fn span_join() {
-    let source1 =
-        "aaa\nbbb".parse::<TokenStream>().unwrap().into_iter().collect::<Vec<_>>();
-    let source2 =
-        "ccc\nddd".parse::<TokenStream>().unwrap().into_iter().collect::<Vec<_>>();
-
-    assert!(source1[0].span.source_file() != source2[0].span.source_file());
-    assert_eq!(source1[0].span.source_file(), source1[1].span.source_file());
-
-    let joined1 = source1[0].span.join(source1[1].span);
-    let joined2 = source1[0].span.join(source2[0].span);
-    assert!(joined1.is_some());
-    assert!(joined2.is_none());
-
-    let start = joined1.unwrap().start();
-    let end = joined1.unwrap().end();
-    assert_eq!(start.line, 1);
-    assert_eq!(start.column, 0);
-    assert_eq!(end.line, 2);
-    assert_eq!(end.column, 3);
-
-    assert_eq!(joined1.unwrap().source_file(), source1[0].span.source_file());
-}
-
-#[test]
-fn no_panic() {
-    let s = str::from_utf8(b"b\'\xc2\x86  \x00\x00\x00^\"").unwrap();
-    assert!(s.parse::<proc_macro2::TokenStream>().is_err());
-}
-
-#[test]
-fn tricky_doc_commaent() {
-    let stream = "/**/".parse::<proc_macro2::TokenStream>().unwrap();
-    let tokens = stream.into_iter().collect::<Vec<_>>();
-    assert!(tokens.is_empty(), "not empty -- {:?}", tokens);
-}
-
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{"Cargo.toml":"c8e98953df6fdcc4bdf6a1b7d970c214e8f5eb0f21da327d1c0916735303cd3a","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"c9a75f18b9ab2927829a208fc6aa2cf4e63b8420887ba29cdb265d6619ae82d5","README.md":"f1812dcc3e666d6bebca97f3739058e1bd8de1a2542c9a8cb258d0a259bd59e1","src/lib.rs":"b63a044edeff7ae12d0733e0a7fe64babf9b593b624fa753639ad3f340f24031","src/to_tokens.rs":"3b7fe0934ce2d9c23d9851ec624349cfa6e9d5cd9ed31c67f25cecce50dc218f","src/tokens.rs":"963474535197c1a79bf60af570470e7a89dce43546ee3186920197fdb40bdd9b","tests/test.rs":"8db237707035f55af7c7ef82c2c3892a048411963dccd019da0148bacae8c3d2"},"package":"1eca14c727ad12702eb4b6bfb5a232287dcf8385cb8ca83a3eeaf6519c44c408"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/Cargo.toml
+++ /dev/null
@@ -1,24 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "quote"
-version = "0.4.2"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-include = ["Cargo.toml", "src/**/*.rs", "tests/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-description = "Quasi-quoting macro quote!(...)"
-documentation = "https://docs.rs/quote/"
-keywords = ["syn"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/dtolnay/quote"
-[dependencies.proc-macro2]
-version = "0.2"
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2016 The Rust Project Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/README.md
+++ /dev/null
@@ -1,135 +0,0 @@
-Rust Quasi-Quoting
-==================
-
-[![Build Status](https://api.travis-ci.org/dtolnay/quote.svg?branch=master)](https://travis-ci.org/dtolnay/quote)
-[![Latest Version](https://img.shields.io/crates/v/quote.svg)](https://crates.io/crates/quote)
-[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/quote/)
-
-This crate provides the [`quote!`] macro for turning Rust syntax tree data
-structures into tokens of source code.
-
-[`quote!`]: https://docs.rs/quote/0.4/quote/macro.quote.html
-
-Procedural macros in Rust receive a stream of tokens as input, execute arbitrary
-Rust code to determine how to manipulate those tokens, and produce a stream of
-tokens to hand back to the compiler to compile into the caller's crate.
-Quasi-quoting is a solution to one piece of that -- producing tokens to return
-to the compiler.
-
-The idea of quasi-quoting is that we write *code* that we treat as *data*.
-Within the `quote!` macro, we can write what looks like code to our text editor
-or IDE. We get all the benefits of the editor's brace matching, syntax
-highlighting, indentation, and maybe autocompletion. But rather than compiling
-that as code into the current crate, we can treat it as data, pass it around,
-mutate it, and eventually hand it back to the compiler as tokens to compile into
-the macro caller's crate.
-
-This crate is motivated by the procedural macro use case, but is a
-general-purpose Rust quasi-quoting library and is not specific to procedural
-macros.
-
-*Version requirement: Quote supports any compiler version back to Rust's very
-first support for procedural macros in Rust 1.15.0.*
-
-```toml
-[dependencies]
-quote = "0.4"
-```
-
-```rust
-#[macro_use]
-extern crate quote;
-```
-
-## Syntax
-
-The quote crate provides a [`quote!`] macro within which you can write Rust code
-that gets packaged into a [`quote::Tokens`] and can be treated as data. You
-should think of `Tokens` as representing a fragment of Rust source code. Call
-`to_string()` on a `Tokens` to get back the fragment of source code as a string,
-or call `into()` to stream them as a `TokenStream` back to the compiler in a
-procedural macro.
-
-[`quote::Tokens`]: https://docs.rs/quote/0.4/quote/struct.Tokens.html
-
-Within the `quote!` macro, interpolation is done with `#var`. Any type
-implementing the [`quote::ToTokens`] trait can be interpolated. This includes
-most Rust primitive types as well as most of the syntax tree types from [`syn`].
-
-[`quote::ToTokens`]: https://docs.rs/quote/0.4/quote/trait.ToTokens.html
-[`syn`]: https://github.com/dtolnay/syn
-
-```rust
-let tokens = quote! {
-    struct SerializeWith #generics #where_clause {
-        value: &'a #field_ty,
-        phantom: ::std::marker::PhantomData<#item_ty>,
-    }
-
-    impl #generics serde::Serialize for SerializeWith #generics #where_clause {
-        fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
-            where S: serde::Serializer
-        {
-            #path(self.value, s)
-        }
-    }
-
-    SerializeWith {
-        value: #value,
-        phantom: ::std::marker::PhantomData::<#item_ty>,
-    }
-};
-```
-
-## Repetition
-
-Repetition is done using `#(...)*` or `#(...),*` similar to `macro_rules!`. This
-iterates through the elements of any variable interpolated within the repetition
-and inserts a copy of the repetition body for each one. The variables in an
-interpolation may be anything that implements `IntoIterator`, including `Vec` or
-a pre-existing iterator.
-
-- `#(#var)*` — no separators
-- `#(#var),*` — the character before the asterisk is used as a separator
-- `#( struct #var; )*` — the repetition can contain other things
-- `#( #k => println!("{}", #v), )*` — even multiple interpolations
-
-Note that there is a difference between `#(#var ,)*` and `#(#var),*`—the latter
-does not produce a trailing comma. This matches the behavior of delimiters in
-`macro_rules!`.
-
-## Hygiene
-
-Any interpolated tokens preserve the `Span` information provided by their
-`ToTokens` implementation. Tokens that originate within a `quote!` invocation
-are spanned with [`Span::def_site()`].
-
-[`Span::def_site()`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html#method.def_site
-
-A different span can be provided explicitly through the [`quote_spanned!`]
-macro.
-
-[`quote_spanned!`]: https://docs.rs/quote/0.4/quote/macro.quote_spanned.html
-
-### Recursion limit
-
-The `quote!` macro relies on deep recursion so some large invocations may fail
-with "recursion limit reached" when you compile. If it fails, bump up the
-recursion limit by adding `#![recursion_limit = "128"]` to your crate. An even
-higher limit may be necessary for especially large invocations. You don't need
-this unless the compiler tells you that you need it.
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/src/lib.rs
+++ /dev/null
@@ -1,501 +0,0 @@
-//! This crate provides the [`quote!`] macro for turning Rust syntax tree data
-//! structures into tokens of source code.
-//!
-//! [`quote!`]: macro.quote.html
-//!
-//! Procedural macros in Rust receive a stream of tokens as input, execute
-//! arbitrary Rust code to determine how to manipulate those tokens, and produce
-//! a stream of tokens to hand back to the compiler to compile into the caller's
-//! crate. Quasi-quoting is a solution to one piece of that -- producing tokens
-//! to return to the compiler.
-//!
-//! The idea of quasi-quoting is that we write *code* that we treat as *data*.
-//! Within the `quote!` macro, we can write what looks like code to our text
-//! editor or IDE. We get all the benefits of the editor's brace matching,
-//! syntax highlighting, indentation, and maybe autocompletion. But rather than
-//! compiling that as code into the current crate, we can treat it as data, pass
-//! it around, mutate it, and eventually hand it back to the compiler as tokens
-//! to compile into the macro caller's crate.
-//!
-//! This crate is motivated by the procedural macro use case, but is a
-//! general-purpose Rust quasi-quoting library and is not specific to procedural
-//! macros.
-//!
-//! *Version requirement: Quote supports any compiler version back to Rust's
-//! very first support for procedural macros in Rust 1.15.0.*
-//!
-//! ```toml
-//! [dependencies]
-//! quote = "0.4"
-//! ```
-//!
-//! ```
-//! #[macro_use]
-//! extern crate quote;
-//! #
-//! # fn main() {}
-//! ```
-//!
-//! # Example
-//!
-//! The following quasi-quoted block of code is something you might find in [a]
-//! procedural macro having to do with data structure serialization. The `#var`
-//! syntax performs interpolation of runtime variables into the quoted tokens.
-//! Check out the documentation of the [`quote!`] macro for more detail about
-//! the syntax. See also the [`quote_spanned!`] macro which is important for
-//! implementing hygienic procedural macros.
-//!
-//! [a]: https://serde.rs/
-//! [`quote_spanned!`]: macro.quote_spanned.html
-//!
-//! ```
-//! # #[macro_use]
-//! # extern crate quote;
-//! #
-//! # fn main() {
-//! #     let generics = "";
-//! #     let where_clause = "";
-//! #     let field_ty = "";
-//! #     let item_ty = "";
-//! #     let path = "";
-//! #     let value = "";
-//! #
-//! let tokens = quote! {
-//!     struct SerializeWith #generics #where_clause {
-//!         value: &'a #field_ty,
-//!         phantom: ::std::marker::PhantomData<#item_ty>,
-//!     }
-//!
-//!     impl #generics serde::Serialize for SerializeWith #generics #where_clause {
-//!         fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
-//!             where S: serde::Serializer
-//!         {
-//!             #path(self.value, s)
-//!         }
-//!     }
-//!
-//!     SerializeWith {
-//!         value: #value,
-//!         phantom: ::std::marker::PhantomData::<#item_ty>,
-//!     }
-//! };
-//! #
-//! # }
-//! ```
-//!
-//! ## Recursion limit
-//!
-//! The `quote!` macro relies on deep recursion so some large invocations may
-//! fail with "recursion limit reached" when you compile. If it fails, bump up
-//! the recursion limit by adding `#![recursion_limit = "128"]` to your crate.
-//! An even higher limit may be necessary for especially large invocations.
-
-// Quote types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/quote/0.4.2")]
-
-extern crate proc_macro2;
-extern crate proc_macro;
-
-mod tokens;
-pub use tokens::Tokens;
-
-mod to_tokens;
-pub use to_tokens::ToTokens;
-
-// Not public API.
-#[doc(hidden)]
-pub mod __rt {
-    // Not public API.
-    pub use proc_macro2::*;
-
-    // Not public API.
-    pub fn parse(tokens: &mut ::Tokens, span: Span, s: &str) {
-        let s: TokenStream = s.parse().expect("invalid token stream");
-        tokens.append_all(s.into_iter().map(|mut t| {
-            t.span = span;
-            t
-        }));
-    }
-
-    // Not public API.
-    pub fn append_kind(tokens: &mut ::Tokens, span: Span, kind: TokenNode) {
-        tokens.append(TokenTree {
-            span: span,
-            kind: kind,
-        })
-    }
-}
-
-/// The whole point.
-///
-/// Performs variable interpolation against the input and produces it as
-/// [`Tokens`]. For returning tokens to the compiler in a procedural macro, use
-/// `into()` to build a `TokenStream`.
-///
-/// [`Tokens`]: struct.Tokens.html
-///
-/// # Interpolation
-///
-/// Variable interpolation is done with `#var` (similar to `$var` in
-/// `macro_rules!` macros). This grabs the `var` variable that is currently in
-/// scope and inserts it in that location in the output tokens. The variable
-/// must implement the [`ToTokens`] trait.
-///
-/// [`ToTokens`]: trait.ToTokens.html
-///
-/// Repetition is done using `#(...)*` or `#(...),*` again similar to
-/// `macro_rules!`. This iterates through the elements of any variable
-/// interpolated within the repetition and inserts a copy of the repetition body
-/// for each one. The variables in an interpolation may be anything that
-/// implements `IntoIterator`, including `Vec` or a pre-existing iterator.
-///
-/// - `#(#var)*` — no separators
-/// - `#(#var),*` — the character before the asterisk is used as a separator
-/// - `#( struct #var; )*` — the repetition can contain other tokens
-/// - `#( #k => println!("{}", #v), )*` — even multiple interpolations
-///
-/// # Hygiene
-///
-/// Any interpolated tokens preserve the `Span` information provided by their
-/// `ToTokens` implementation. Tokens that originate within the `quote!`
-/// invocation are spanned with [`Span::def_site()`].
-///
-/// [`Span::def_site()`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html#method.def_site
-///
-/// A different span can be provided through the [`quote_spanned!`] macro.
-///
-/// [`quote_spanned!`]: macro.quote_spanned.html
-///
-/// # Example
-///
-/// ```
-/// extern crate proc_macro;
-///
-/// #[macro_use]
-/// extern crate quote;
-///
-/// use proc_macro::TokenStream;
-///
-/// # const IGNORE_TOKENS: &'static str = stringify! {
-/// #[proc_macro_derive(HeapSize)]
-/// # };
-/// pub fn derive_heap_size(input: TokenStream) -> TokenStream {
-///     // Parse the input and figure out what implementation to generate...
-///     # const IGNORE_TOKENS: &'static str = stringify! {
-///     let name = /* ... */;
-///     let expr = /* ... */;
-///     # };
-///     #
-///     # let name = 0;
-///     # let expr = 0;
-///
-///     let expanded = quote! {
-///         // The generated impl.
-///         impl ::heapsize::HeapSize for #name {
-///             fn heap_size_of_children(&self) -> usize {
-///                 #expr
-///             }
-///         }
-///     };
-///
-///     // Hand the output tokens back to the compiler.
-///     expanded.into()
-/// }
-/// #
-/// # fn main() {}
-/// ```
-#[macro_export]
-macro_rules! quote {
-    ($($tt:tt)*) => (quote_spanned!($crate::__rt::Span::def_site()=> $($tt)*));
-}
-
-/// Same as `quote!`, but applies a given span to all tokens originating within
-/// the macro invocation.
-///
-/// # Syntax
-///
-/// A span expression of type [`Span`], followed by `=>`, followed by the tokens
-/// to quote. The span expression should be brief -- use a variable for anything
-/// more than a few characters. There should be no space before the `=>` token.
-///
-/// [`Span`]: https://docs.rs/proc-macro2/0.2/proc_macro2/struct.Span.html
-///
-/// ```
-/// # #[macro_use]
-/// # extern crate quote;
-/// # extern crate proc_macro2;
-/// #
-/// # use proc_macro2::Span;
-/// #
-/// # fn main() {
-/// # const IGNORE_TOKENS: &'static str = stringify! {
-/// let span = /* ... */;
-/// # };
-/// # let span = Span::call_site();
-/// # let init = 0;
-///
-/// // On one line, use parentheses.
-/// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init)));
-///
-/// // On multiple lines, place the span at the top and use braces.
-/// let tokens = quote_spanned! {span=>
-///     Box::into_raw(Box::new(#init))
-/// };
-/// # }
-/// ```
-///
-/// # Hygiene
-///
-/// Any interpolated tokens preserve the `Span` information provided by their
-/// `ToTokens` implementation. Tokens that originate within the `quote_spanned!`
-/// invocation are spanned with the given span argument.
-///
-/// # Example
-///
-/// The following procedural macro code uses `quote_spanned!` to assert that a
-/// particular Rust type implements the [`Sync`] trait so that references can be
-/// safely shared between threads.
-///
-/// [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-///
-/// ```
-/// # #[macro_use]
-/// # extern crate quote;
-/// # extern crate proc_macro2;
-/// #
-/// # use quote::{Tokens, ToTokens};
-/// # use proc_macro2::Span;
-/// #
-/// # struct Type;
-/// #
-/// # impl Type {
-/// #     fn span(&self) -> Span {
-/// #         Span::call_site()
-/// #     }
-/// # }
-/// #
-/// # impl ToTokens for Type {
-/// #     fn to_tokens(&self, _tokens: &mut Tokens) {}
-/// # }
-/// #
-/// # fn main() {
-/// # let ty = Type;
-/// # let def_site = Span::def_site();
-/// #
-/// let ty_span = ty.span().resolved_at(def_site);
-/// let assert_sync = quote_spanned! {ty_span=>
-///     struct _AssertSync where #ty: Sync;
-/// };
-/// # }
-/// ```
-///
-/// If the assertion fails, the user will see an error like the following. The
-/// input span of their type is hightlighted in the error.
-///
-/// ```text
-/// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied
-///   --> src/main.rs:10:21
-///    |
-/// 10 |     static ref PTR: *const () = &();
-///    |                     ^^^^^^^^^ `*const ()` cannot be shared between threads safely
-/// ```
-///
-/// In this example it is important for the where-clause to be spanned with the
-/// line/column information of the user's input type so that error messages are
-/// placed appropriately by the compiler. But it is also incredibly important
-/// that `Sync` resolves at the macro definition site and not the macro call
-/// site. If we resolve `Sync` at the same span that the user's type is going to
-/// be resolved, then they could bypass our check by defining their own trait
-/// named `Sync` that is implemented for their type.
-#[macro_export]
-macro_rules! quote_spanned {
-    ($span:expr=> $($tt:tt)*) => {
-        {
-            let mut _s = $crate::Tokens::new();
-            let _span = $span;
-            quote_each_token!(_s _span $($tt)*);
-            _s
-        }
-    };
-}
-
-// Extract the names of all #metavariables and pass them to the $finish macro.
-//
-// in:   pounded_var_names!(then () a #b c #( #d )* #e)
-// out:  then!(() b d e)
-#[macro_export]
-#[doc(hidden)]
-macro_rules! pounded_var_names {
-    ($finish:ident ($($found:ident)*) # ( $($inner:tt)* ) $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) # [ $($inner:tt)* ] $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) # { $($inner:tt)* } $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) # $first:ident $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)* $first) $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) ( $($inner:tt)* ) $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) [ $($inner:tt)* ] $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) { $($inner:tt)* } $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($inner)* $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*) $ignore:tt $($rest:tt)*) => {
-        pounded_var_names!($finish ($($found)*) $($rest)*)
-    };
-
-    ($finish:ident ($($found:ident)*)) => {
-        $finish!(() $($found)*)
-    };
-}
-
-// in:   nested_tuples_pat!(() a b c d e)
-// out:  ((((a b) c) d) e)
-//
-// in:   nested_tuples_pat!(() a)
-// out:  a
-#[macro_export]
-#[doc(hidden)]
-macro_rules! nested_tuples_pat {
-    (()) => {
-        &()
-    };
-
-    (() $first:ident $($rest:ident)*) => {
-        nested_tuples_pat!(($first) $($rest)*)
-    };
-
-    (($pat:pat) $first:ident $($rest:ident)*) => {
-        nested_tuples_pat!((($pat, $first)) $($rest)*)
-    };
-
-    (($done:pat)) => {
-        $done
-    };
-}
-
-// in:   multi_zip_expr!(() a b c d e)
-// out:  a.into_iter().zip(b).zip(c).zip(d).zip(e)
-//
-// in:   multi_zip_iter!(() a)
-// out:  a
-#[macro_export]
-#[doc(hidden)]
-macro_rules! multi_zip_expr {
-    (()) => {
-        &[]
-    };
-
-    (() $single:ident) => {
-        $single
-    };
-
-    (() $first:ident $($rest:ident)*) => {
-        multi_zip_expr!(($first.into_iter()) $($rest)*)
-    };
-
-    (($zips:expr) $first:ident $($rest:ident)*) => {
-        multi_zip_expr!(($zips.zip($first)) $($rest)*)
-    };
-
-    (($done:expr)) => {
-        $done
-    };
-}
-
-#[macro_export]
-#[doc(hidden)]
-macro_rules! quote_each_token {
-    ($tokens:ident $span:ident) => {};
-
-    ($tokens:ident $span:ident # ! $($rest:tt)*) => {
-        quote_each_token!($tokens $span #);
-        quote_each_token!($tokens $span !);
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident # ( $($inner:tt)* ) * $($rest:tt)*) => {
-        for pounded_var_names!(nested_tuples_pat () $($inner)*)
-        in pounded_var_names!(multi_zip_expr () $($inner)*) {
-            quote_each_token!($tokens $span $($inner)*);
-        }
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident # ( $($inner:tt)* ) $sep:tt * $($rest:tt)*) => {
-        for (_i, pounded_var_names!(nested_tuples_pat () $($inner)*))
-        in pounded_var_names!(multi_zip_expr () $($inner)*).into_iter().enumerate() {
-            if _i > 0 {
-                quote_each_token!($tokens $span $sep);
-            }
-            quote_each_token!($tokens $span $($inner)*);
-        }
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident # [ $($inner:tt)* ] $($rest:tt)*) => {
-        quote_each_token!($tokens $span #);
-        $crate::__rt::append_kind(&mut $tokens,
-            $span,
-            $crate::__rt::TokenNode::Group(
-                $crate::__rt::Delimiter::Bracket,
-                quote_spanned!($span=> $($inner)*).into()
-            ));
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident # $first:ident $($rest:tt)*) => {
-        $crate::ToTokens::to_tokens(&$first, &mut $tokens);
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident ( $($first:tt)* ) $($rest:tt)*) => {
-        $crate::__rt::append_kind(&mut $tokens,
-            $span,
-            $crate::__rt::TokenNode::Group(
-                $crate::__rt::Delimiter::Parenthesis,
-                quote_spanned!($span=> $($first)*).into()
-            ));
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident [ $($first:tt)* ] $($rest:tt)*) => {
-        $crate::__rt::append_kind(&mut $tokens,
-            $span,
-            $crate::__rt::TokenNode::Group(
-                $crate::__rt::Delimiter::Bracket,
-                quote_spanned!($span=> $($first)*).into()
-            ));
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident { $($first:tt)* } $($rest:tt)*) => {
-        $crate::__rt::append_kind(&mut $tokens,
-            $span,
-            $crate::__rt::TokenNode::Group(
-                $crate::__rt::Delimiter::Brace,
-                quote_spanned!($span=> $($first)*).into()
-            ));
-        quote_each_token!($tokens $span $($rest)*);
-    };
-
-    ($tokens:ident $span:ident $first:tt $($rest:tt)*) => {
-        // TODO: this seems slow... special case some `:tt` arguments?
-        $crate::__rt::parse(&mut $tokens, $span, stringify!($first));
-        quote_each_token!($tokens $span $($rest)*);
-    };
-}
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/src/to_tokens.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-use super::Tokens;
-
-use std::borrow::Cow;
-
-use proc_macro2::{Literal, Span, Term, TokenNode, TokenTree, TokenStream};
-
-fn tt(kind: TokenNode) -> TokenTree {
-    TokenTree {
-        span: Span::def_site(),
-        kind: kind,
-    }
-}
-
-/// Types that can be interpolated inside a [`quote!`] invocation.
-///
-/// [`quote!`]: macro.quote.html
-pub trait ToTokens {
-    /// Write `self` to the given `Tokens`.
-    ///
-    /// Example implementation for a struct representing Rust paths like
-    /// `std::cmp::PartialEq`:
-    ///
-    /// ```
-    /// extern crate quote;
-    /// use quote::{Tokens, ToTokens};
-    ///
-    /// extern crate proc_macro2;
-    /// use proc_macro2::{TokenTree, TokenNode, Spacing, Span};
-    ///
-    /// pub struct Path {
-    ///     pub global: bool,
-    ///     pub segments: Vec<PathSegment>,
-    /// }
-    ///
-    /// impl ToTokens for Path {
-    ///     fn to_tokens(&self, tokens: &mut Tokens) {
-    ///         for (i, segment) in self.segments.iter().enumerate() {
-    ///             if i > 0 || self.global {
-    ///                 // Double colon `::`
-    ///                 tokens.append(TokenTree {
-    ///                     span: Span::def_site(),
-    ///                     kind: TokenNode::Op(':', Spacing::Joint),
-    ///                 });
-    ///                 tokens.append(TokenTree {
-    ///                     span: Span::def_site(),
-    ///                     kind: TokenNode::Op(':', Spacing::Alone),
-    ///                 });
-    ///             }
-    ///             segment.to_tokens(tokens);
-    ///         }
-    ///     }
-    /// }
-    /// #
-    /// # pub struct PathSegment;
-    /// #
-    /// # impl ToTokens for PathSegment {
-    /// #     fn to_tokens(&self, tokens: &mut Tokens) {
-    /// #         unimplemented!()
-    /// #     }
-    /// # }
-    /// #
-    /// # fn main() {}
-    /// ```
-    fn to_tokens(&self, tokens: &mut Tokens);
-
-    /// Convert `self` directly into a `Tokens` object.
-    ///
-    /// This method is implicitly implemented using `to_tokens`, and acts as a
-    /// convenience method for consumers of the `ToTokens` trait.
-    fn into_tokens(self) -> Tokens
-    where
-        Self: Sized,
-    {
-        let mut tokens = Tokens::new();
-        self.to_tokens(&mut tokens);
-        tokens
-    }
-}
-
-impl<'a, T: ?Sized + ToTokens> ToTokens for &'a T {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<'a, T: ?Sized + ToOwned + ToTokens> ToTokens for Cow<'a, T> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<T: ?Sized + ToTokens> ToTokens for Box<T> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        (**self).to_tokens(tokens);
-    }
-}
-
-impl<T: ToTokens> ToTokens for Option<T> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        if let Some(ref t) = *self {
-            t.to_tokens(tokens);
-        }
-    }
-}
-
-impl ToTokens for str {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        tokens.append(tt(TokenNode::Literal(Literal::string(self))));
-    }
-}
-
-impl ToTokens for String {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        self.as_str().to_tokens(tokens);
-    }
-}
-
-macro_rules! primitive {
-    ($($t:ident)*) => ($(
-        impl ToTokens for $t {
-            fn to_tokens(&self, tokens: &mut Tokens) {
-                tokens.append(tt(TokenNode::Literal(Literal::$t(*self))));
-            }
-        }
-    )*)
-}
-
-primitive! {
-    i8 i16 i32 i64 isize
-    u8 u16 u32 u64 usize
-    f32 f64
-}
-
-impl ToTokens for char {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        tokens.append(tt(TokenNode::Literal(Literal::character(*self))));
-    }
-}
-
-impl ToTokens for bool {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        let word = if *self { "true" } else { "false" };
-        tokens.append(tt(TokenNode::Term(Term::intern(word))));
-    }
-}
-
-impl ToTokens for Term {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        tokens.append(tt(TokenNode::Term(*self)));
-    }
-}
-
-impl ToTokens for Literal {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        tokens.append(tt(TokenNode::Literal(self.clone())));
-    }
-}
-
-impl ToTokens for TokenNode {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        tokens.append(tt(self.clone()));
-    }
-}
-
-impl ToTokens for TokenTree {
-    fn to_tokens(&self, dst: &mut Tokens) {
-        dst.append(self.clone());
-    }
-}
-
-impl ToTokens for TokenStream {
-    fn to_tokens(&self, dst: &mut Tokens) {
-        dst.append_all(self.clone().into_iter());
-    }
-}
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/src/tokens.rs
+++ /dev/null
@@ -1,264 +0,0 @@
-use super::ToTokens;
-use std::fmt::{self, Debug, Display};
-use std::hash::{Hash, Hasher};
-
-use proc_macro;
-use proc_macro2::{TokenStream, TokenTree};
-
-/// Tokens produced by a [`quote!`] invocation.
-///
-/// [`quote!`]: macro.quote.html
-#[derive(Clone, Default)]
-pub struct Tokens {
-    tts: Vec<TokenTree>,
-}
-
-impl Tokens {
-    /// Empty tokens.
-    pub fn new() -> Self {
-        Tokens { tts: Vec::new() }
-    }
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends the token specified to this list of tokens.
-    pub fn append<U>(&mut self, token: U)
-    where
-        U: Into<TokenTree>,
-    {
-        self.tts.push(token.into());
-    }
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// ```
-    /// # #[macro_use] extern crate quote;
-    /// # use quote::{Tokens, ToTokens};
-    /// # fn main() {
-    /// struct X;
-    ///
-    /// impl ToTokens for X {
-    ///     fn to_tokens(&self, tokens: &mut Tokens) {
-    ///         tokens.append_all(&[true, false]);
-    ///     }
-    /// }
-    ///
-    /// let tokens = quote!(#X);
-    /// assert_eq!(tokens.to_string(), "true false");
-    /// # }
-    /// ```
-    pub fn append_all<T, I>(&mut self, iter: I)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>,
-    {
-        for token in iter {
-            token.to_tokens(self);
-        }
-    }
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all of the items in the iterator `I`, separated by the tokens
-    /// `U`.
-    pub fn append_separated<T, I, U>(&mut self, iter: I, op: U)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>,
-        U: ToTokens,
-    {
-        for (i, token) in iter.into_iter().enumerate() {
-            if i > 0 {
-                op.to_tokens(self);
-            }
-            token.to_tokens(self);
-        }
-    }
-
-    /// For use by `ToTokens` implementations.
-    ///
-    /// Appends all tokens in the iterator `I`, appending `U` after each
-    /// element, including after the last element of the iterator.
-    pub fn append_terminated<T, I, U>(&mut self, iter: I, term: U)
-    where
-        T: ToTokens,
-        I: IntoIterator<Item = T>,
-        U: ToTokens,
-    {
-        for token in iter {
-            token.to_tokens(self);
-            term.to_tokens(self);
-        }
-    }
-}
-
-impl ToTokens for Tokens {
-    fn to_tokens(&self, dst: &mut Tokens) {
-        dst.tts.extend(self.tts.iter().cloned());
-    }
-
-    fn into_tokens(self) -> Tokens {
-        self
-    }
-}
-
-impl From<Tokens> for TokenStream {
-    fn from(tokens: Tokens) -> TokenStream {
-        tokens.tts.into_iter().collect()
-    }
-}
-
-impl From<Tokens> for proc_macro::TokenStream {
-    fn from(tokens: Tokens) -> proc_macro::TokenStream {
-        TokenStream::from(tokens).into()
-    }
-}
-
-/// Allows a `Tokens` to be passed to `Tokens::append_all`.
-impl IntoIterator for Tokens {
-    type Item = TokenTree;
-    type IntoIter = private::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        private::into_iter(self.tts.into_iter())
-    }
-}
-
-mod private {
-    use std::vec;
-    use proc_macro2::TokenTree;
-
-    pub struct IntoIter(vec::IntoIter<TokenTree>);
-
-    pub fn into_iter(tts: vec::IntoIter<TokenTree>) -> IntoIter {
-        IntoIter(tts)
-    }
-
-    impl Iterator for IntoIter {
-        type Item = TokenTree;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            self.0.next()
-        }
-    }
-}
-
-impl Display for Tokens {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(&TokenStream::from(self.clone()), formatter)
-    }
-}
-
-impl Debug for Tokens {
-    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        struct DebugAsDisplay<'a, T: 'a>(&'a T);
-
-        impl<'a, T> Debug for DebugAsDisplay<'a, T>
-        where
-            T: Display,
-        {
-            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                Display::fmt(self.0, formatter)
-            }
-        }
-
-        formatter
-            .debug_tuple("Tokens")
-            .field(&DebugAsDisplay(self))
-            .finish()
-    }
-}
-
-fn tt_eq(a: &TokenTree, b: &TokenTree) -> bool {
-    use proc_macro2::{TokenNode, Delimiter, Spacing};
-
-    match (&a.kind, &b.kind) {
-        (&TokenNode::Group(d1, ref s1), &TokenNode::Group(d2, ref s2)) => {
-            match (d1, d2) {
-                (Delimiter::Parenthesis, Delimiter::Parenthesis)
-                | (Delimiter::Brace, Delimiter::Brace)
-                | (Delimiter::Bracket, Delimiter::Bracket)
-                | (Delimiter::None, Delimiter::None) => {}
-                _ => return false,
-            }
-
-            let s1 = s1.clone().into_iter();
-            let mut s2 = s2.clone().into_iter();
-
-            for item1 in s1 {
-                let item2 = match s2.next() {
-                    Some(item) => item,
-                    None => return false,
-                };
-                if !tt_eq(&item1, &item2) {
-                    return false;
-                }
-            }
-            s2.next().is_none()
-        }
-        (&TokenNode::Op(o1, k1), &TokenNode::Op(o2, k2)) => {
-            o1 == o2 && match (k1, k2) {
-                (Spacing::Alone, Spacing::Alone) | (Spacing::Joint, Spacing::Joint) => true,
-                _ => false,
-            }
-        }
-        (&TokenNode::Literal(ref l1), &TokenNode::Literal(ref l2)) => {
-            l1.to_string() == l2.to_string()
-        }
-        (&TokenNode::Term(ref s1), &TokenNode::Term(ref s2)) => s1.as_str() == s2.as_str(),
-        _ => false,
-    }
-}
-
-impl PartialEq for Tokens {
-    fn eq(&self, other: &Self) -> bool {
-        if self.tts.len() != other.tts.len() {
-            return false;
-        }
-
-        self.tts
-            .iter()
-            .zip(other.tts.iter())
-            .all(|(a, b)| tt_eq(a, b))
-    }
-}
-
-fn tt_hash<H: Hasher>(tt: &TokenTree, h: &mut H) {
-    use proc_macro2::{TokenNode, Delimiter, Spacing};
-
-    match tt.kind {
-        TokenNode::Group(delim, ref stream) => {
-            0u8.hash(h);
-            match delim {
-                Delimiter::Parenthesis => 0u8.hash(h),
-                Delimiter::Brace => 1u8.hash(h),
-                Delimiter::Bracket => 2u8.hash(h),
-                Delimiter::None => 3u8.hash(h),
-            }
-
-            for item in stream.clone() {
-                tt_hash(&item, h);
-            }
-            0xffu8.hash(h); // terminator w/ a variant we don't normally hash
-        }
-        TokenNode::Op(op, kind) => {
-            1u8.hash(h);
-            op.hash(h);
-            match kind {
-                Spacing::Alone => 0u8.hash(h),
-                Spacing::Joint => 1u8.hash(h),
-            }
-        }
-        TokenNode::Literal(ref lit) => (2u8, lit.to_string()).hash(h),
-        TokenNode::Term(ref word) => (3u8, word.as_str()).hash(h),
-    }
-}
-
-impl<'a> Hash for Tokens {
-    fn hash<H: Hasher>(&self, h: &mut H) {
-        self.tts.len().hash(h);
-        for tt in &self.tts {
-            tt_hash(&tt, h);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/quote-0.4.2/tests/test.rs
+++ /dev/null
@@ -1,292 +0,0 @@
-#![cfg_attr(feature = "cargo-clippy", allow(blacklisted_name))]
-
-use std::borrow::Cow;
-
-extern crate proc_macro2;
-#[macro_use]
-extern crate quote;
-
-use proc_macro2::{Span, Term};
-
-struct X;
-
-impl quote::ToTokens for X {
-    fn to_tokens(&self, tokens: &mut quote::Tokens) {
-        tokens.append(proc_macro2::TokenTree {
-            kind: proc_macro2::TokenNode::Term(Term::intern("X")),
-            span: Span::def_site(),
-        });
-    }
-}
-
-#[test]
-fn test_quote_impl() {
-    let tokens = quote!(
-        impl<'a, T: ToTokens> ToTokens for &'a T {
-            fn to_tokens(&self, tokens: &mut Tokens) {
-                (**self).to_tokens(tokens)
-            }
-        }
-    );
-
-    let expected = concat!(
-        "impl < 'a , T : ToTokens > ToTokens for & 'a T { ",
-        "fn to_tokens ( & self , tokens : & mut Tokens ) { ",
-        "( * * self ) . to_tokens ( tokens ) ",
-        "} ",
-        "}"
-    );
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_substitution() {
-    let x = X;
-    let tokens = quote!(#x <#x> (#x) [#x] {#x});
-
-    let expected = "X < X > ( X ) [ X ] { X }";
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_iter() {
-    let primes = &[X, X, X, X];
-
-    assert_eq!("X X X X", quote!(#(#primes)*).to_string());
-
-    assert_eq!("X , X , X , X ,", quote!(#(#primes,)*).to_string());
-
-    assert_eq!("X , X , X , X", quote!(#(#primes),*).to_string());
-}
-
-#[test]
-fn test_advanced() {
-    let generics = quote!( <'a, T> );
-
-    let where_clause = quote!( where T: Serialize );
-
-    let field_ty = quote!(String);
-
-    let item_ty = quote!(Cow<'a, str>);
-
-    let path = quote!(SomeTrait::serialize_with);
-
-    let value = quote!(self.x);
-
-    let tokens = quote! {
-        struct SerializeWith #generics #where_clause {
-            value: &'a #field_ty,
-            phantom: ::std::marker::PhantomData<#item_ty>,
-        }
-
-        impl #generics ::serde::Serialize for SerializeWith #generics #where_clause {
-            fn serialize<S>(&self, s: &mut S) -> Result<(), S::Error>
-                where S: ::serde::Serializer
-            {
-                #path(self.value, s)
-            }
-        }
-
-        SerializeWith {
-            value: #value,
-            phantom: ::std::marker::PhantomData::<#item_ty>,
-        }
-    };
-
-    let expected = concat!(
-        "struct SerializeWith < 'a , T > where T : Serialize { ",
-        "value : & 'a String , ",
-        "phantom : :: std :: marker :: PhantomData < Cow < 'a , str > > , ",
-        "} ",
-        "impl < 'a , T > :: serde :: Serialize for SerializeWith < 'a , T > where T : Serialize { ",
-        "fn serialize < S > ( & self , s : & mut S ) -> Result < ( ) , S :: Error > ",
-        "where S : :: serde :: Serializer ",
-        "{ ",
-        "SomeTrait :: serialize_with ( self . value , s ) ",
-        "} ",
-        "} ",
-        "SerializeWith { ",
-        "value : self . x , ",
-        "phantom : :: std :: marker :: PhantomData :: < Cow < 'a , str > > , ",
-        "}"
-    );
-
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_integer() {
-    let ii8 = -1i8;
-    let ii16 = -1i16;
-    let ii32 = -1i32;
-    let ii64 = -1i64;
-    let iisize = -1isize;
-    let uu8 = 1u8;
-    let uu16 = 1u16;
-    let uu32 = 1u32;
-    let uu64 = 1u64;
-    let uusize = 1usize;
-
-    let tokens = quote! {
-        #ii8 #ii16 #ii32 #ii64 #iisize
-        #uu8 #uu16 #uu32 #uu64 #uusize
-    };
-    let expected = "-1i8 -1i16 -1i32 -1i64 -1isize 1u8 1u16 1u32 1u64 1usize";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_floating() {
-    let e32 = 2.345f32;
-
-    let e64 = 2.345f64;
-
-    let tokens = quote! {
-        #e32
-        #e64
-    };
-    let expected = concat!("2.345f32 2.345f64");
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_char() {
-    let zero = '\0';
-    let pound = '#';
-    let quote = '"';
-    let apost = '\'';
-    let newline = '\n';
-    let heart = '\u{2764}';
-
-    let tokens = quote! {
-        #zero #pound #quote #apost #newline #heart
-    };
-    let expected = "'\\u{0}' '#' '\\\"' '\\'' '\\n' '\\u{2764}'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_str() {
-    let s = "\0 a 'b \" c";
-    let tokens = quote!(#s);
-    let expected = "\"\\u{0} a \\'b \\\" c\"";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_string() {
-    let s = "\0 a 'b \" c".to_string();
-    let tokens = quote!(#s);
-    let expected = "\"\\u{0} a \\'b \\\" c\"";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_ident() {
-    let foo = Term::intern("Foo");
-    let bar = Term::intern(&format!("Bar{}", 7));
-    let tokens = quote!(struct #foo; enum #bar {});
-    let expected = "struct Foo ; enum Bar7 { }";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_duplicate() {
-    let ch = 'x';
-
-    let tokens = quote!(#ch #ch);
-
-    let expected = "'x' 'x'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_fancy_repetition() {
-    let foo = vec!["a", "b"];
-    let bar = vec![true, false];
-
-    let tokens = quote! {
-        #(#foo: #bar),*
-    };
-
-    let expected = r#""a" : true , "b" : false"#;
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_nested_fancy_repetition() {
-    let nested = vec![vec!['a', 'b', 'c'], vec!['x', 'y', 'z']];
-
-    let tokens = quote! {
-        #(
-            #(#nested)*
-        ),*
-    };
-
-    let expected = "'a' 'b' 'c' , 'x' 'y' 'z'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_empty_repetition() {
-    let tokens = quote!(#(a b)* #(c d),*);
-    assert_eq!("", tokens.to_string());
-}
-
-#[test]
-fn test_variable_name_conflict() {
-    // The implementation of `#(...),*` uses the variable `_i` but it should be
-    // fine, if a little confusing when debugging.
-    let _i = vec!['a', 'b'];
-    let tokens = quote! { #(#_i),* };
-    let expected = "'a' , 'b'";
-    assert_eq!(expected, tokens.to_string());
-}
-
-#[test]
-fn test_empty_quote() {
-    let tokens = quote!();
-    assert_eq!("", tokens.to_string());
-}
-
-#[test]
-fn test_box_str() {
-    let b = "str".to_owned().into_boxed_str();
-    let tokens = quote! { #b };
-    assert_eq!("\"str\"", tokens.to_string());
-}
-
-#[test]
-fn test_cow() {
-    let owned: Cow<Term> = Cow::Owned(Term::intern("owned"));
-
-    let ident = Term::intern("borrowed");
-    let borrowed = Cow::Borrowed(&ident);
-
-    let tokens = quote! { #owned #borrowed };
-    assert_eq!("owned borrowed", tokens.to_string());
-}
-
-#[test]
-fn test_closure() {
-    fn field_i(i: usize) -> Term {
-        Term::intern(&format!("__field{}", i))
-    }
-
-    let fields = (0usize..3)
-        .map(field_i as fn(_) -> _)
-        .map(|var| quote! { #var });
-
-    let tokens = quote! { #(#fields)* };
-    assert_eq!("__field0 __field1 __field2", tokens.to_string());
-}
-
-#[test]
-fn test_append_tokens() {
-    let mut a = quote!(a);
-    let b = quote!(b);
-    a.append_all(b);
-    assert_eq!("a b", a.to_string());
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{"Cargo.toml":"8c4299d297c1f5d0f6afcfedde821e5cdf1893607290af92aebd9b4b86c48386","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"f033c371492a4769d377a8bf1a139adc7bf94ea00595b867a3e234eeab994c8c","README.md":"632c404dd064731af5fd71e643fbba83ced6ac9198497b672139bada194cf41b","src/attr.rs":"35cc8556dd26662d79c3059315de5a5758ce18b697a8ce32361b09ce1a820a0e","src/buffer.rs":"81ca1506c599cfba1136d9fec2d83137f4a4085b341658a4155d978f31b64552","src/data.rs":"d052602339af37df6454a07fd1163e382571d8665529450339cfe55773e308ae","src/derive.rs":"eed8e88cd763e852782b10d2366a81e52d3ec0777676eaa94827ea3b46151134","src/error.rs":"db9f0648e7399cfcaef9c431b452b5012a6056e75c586212e2cfdb1e18b8c69a","src/expr.rs":"274d9f462225432a3ff0c611a1db44b0b3cc6a673b8c8df2a53bd00cf3a5be95","src/file.rs":"43d5b12828a5c2a0bbef7baa56b0b9638575d73d84e0babaf0e85cdc2d573f16","src/gen/fold.rs":"3bf425ce1a461ce527799e2624a311081e35adc133de3acd5195638024a6872f","src/gen/visit.rs":"6f58e84d9b304d8e8493c01ac71d1d36e61c9e18355d60d06e890b94cdb513d0","src/gen/visit_mut.rs":"537dc348ce5a7353d0d0456138043e4ce916c2ca57c90da10500856ac6393dfe","src/gen_helper.rs":"2be46ff201fd53908350bde4d6c8b7dc427dbd156fa538869a9ccbdf6279af04","src/generics.rs":"5dc13558159085b4743d7a0a65f6cfda735c2a23071c588a7dc215834e0c6b44","src/ident.rs":"ea657c29ee5d483ac59664f808fae3e522e18578d86764b7efcceafc6d8236ca","src/item.rs":"f000f831e6f24de60a7ff7e6164f6adc93ae0fb5d0dc5efc6488bb9519f43dd8","src/lib.rs":"dd1212af93788c6a01193d67185b4258a92c7b6c3f34af395f3ed08174117fdd","src/lifetime.rs":"2c92822a1dfc72738b64d787ef9f7ceb1251e689cacb9e780dc784f99b2d9321","src/lit.rs":"7d0eea1b0057d0ae1bce21815b8fe0ee97b0cd287a8d10e4ff74419b7d6fbefe","src/mac.rs":"ec945e4926de028c153c87f1643e8910e53738d8a4b519b74254479e61acabec","src/macros.rs":"b975b110f9b904e5d82bd0222f7cd0398825fcde146c2b98b581daccf2eb8341","src/op.rs":"b9f9ff8027fc65403858d8fed7d0ac3c919d70f97f830fd7532fb22e1dea993b","src/parse_quote.rs":"b0221332823786d664de3e4976cdd3962ca5fa3c1558bb57f9c8810348ded0b0","src/parsers.rs":"9ef1c5e7760a7a4132fe6834dda5871ff9b6513f51243008f710ee4fe973529d","src/path.rs":"01455551da12e8782b4c97ccb8c670d81ea1db1264393a73577535141d5266a8","src/punctuated.rs":"87312dc0d057935774ac64e2c2fdfdae7f693b128c53415d76d78ca377098ced","src/spanned.rs":"9343c288a6d07a0d306c9bd2f332b8eb91fb657f88ec8fbb336ad1b667b583dd","src/synom.rs":"74d8c022ef216f798268999c9c934dca05ad75914d60fc2b445d3a7201826f0d","src/token.rs":"4f16136315cc9ff1e707e80bde148d9471f7e4708c30e07b9c1d3a0bc98805fd","src/tt.rs":"2e10762c00bce15a8e22125bba26c856112e701a82f849aa0d46701e6228823f","src/ty.rs":"0f73cc4626171be4ab2a1de9b2c0c94229055a762ba50ba9ba41b29908447867"},"package":"9e1c669ed757c0ebd04337f6a5bb972d05e0c08fe2540dd3ee3dd9e4daf1604c"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/Cargo.toml
+++ /dev/null
@@ -1,55 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g. crates.io) dependencies
-#
-# If you believe there's an error in this file please file an
-# issue against the rust-lang/cargo repository. If you're
-# editing this file be aware that the upstream Cargo.toml
-# will likely look very different (and much more reasonable)
-
-[package]
-name = "syn"
-version = "0.12.12"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-include = ["/Cargo.toml", "/src/**/*.rs", "/README.md", "/LICENSE-APACHE", "/LICENSE-MIT"]
-description = "Nom parser for Rust source code"
-documentation = "https://docs.rs/syn"
-categories = ["development-tools::procedural-macro-helpers"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/dtolnay/syn"
-[package.metadata.docs.rs]
-all-features = true
-
-[[example]]
-name = "dump-syntax"
-path = "examples/dump-syntax/main.rs"
-required-features = ["full", "parsing", "extra-traits"]
-[dependencies.proc-macro2]
-version = "0.2"
-
-[dependencies.quote]
-version = "0.4"
-optional = true
-
-[dependencies.unicode-xid]
-version = "0.1"
-[dev-dependencies.rayon]
-version = "0.9"
-
-[dev-dependencies.walkdir]
-version = "1.0.1"
-
-[features]
-clone-impls = []
-default = ["derive", "parsing", "printing", "clone-impls"]
-derive = []
-extra-traits = []
-fold = []
-full = []
-parsing = []
-printing = ["quote"]
-visit = []
-visit-mut = []
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-   To apply the Apache License to your work, attach the following
-   boilerplate notice, with the fields enclosed by brackets "[]"
-   replaced with your own identifying information. (Don't include
-   the brackets!)  The text should be enclosed in the appropriate
-   comment syntax for the file format. We also recommend that a
-   file or class name and description of purpose be included on the
-   same "printed page" as the copyright notice for easier
-   identification within third-party archives.
-
-Copyright [yyyy] [name of copyright owner]
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/LICENSE-MIT
+++ /dev/null
@@ -1,25 +0,0 @@
-Copyright (c) 2018 Syn Developers
-
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/README.md
+++ /dev/null
@@ -1,277 +0,0 @@
-Nom parser for Rust source code
-===============================
-
-[![Build Status](https://api.travis-ci.org/dtolnay/syn.svg?branch=master)](https://travis-ci.org/dtolnay/syn)
-[![Latest Version](https://img.shields.io/crates/v/syn.svg)](https://crates.io/crates/syn)
-[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/syn/0.12/syn/)
-
-Syn is a parsing library for parsing a stream of Rust tokens into a syntax tree
-of Rust source code.
-
-Currently this library is geared toward the [custom derive] use case but
-contains some APIs that may be useful for Rust procedural macros more generally.
-
-[custom derive]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
-
-- **Data structures** — Syn provides a complete syntax tree that can represent
-  any valid Rust source code. The syntax tree is rooted at [`syn::File`] which
-  represents a full source file, but there are other entry points that may be
-  useful to procedural macros including [`syn::Item`], [`syn::Expr`] and
-  [`syn::Type`].
-
-- **Custom derives** — Of particular interest to custom derives is
-  [`syn::DeriveInput`] which is any of the three legal input items to a derive
-  macro. An example below shows using this type in a library that can derive
-  implementations of a trait of your own.
-
-- **Parser combinators** — Parsing in Syn is built on a suite of public parser
-  combinator macros that you can use for parsing any token-based syntax you
-  dream up within a `functionlike!(...)` procedural macro. Every syntax tree
-  node defined by Syn is individually parsable and may be used as a building
-  block for custom syntaxes, or you may do it all yourself working from the most
-  primitive tokens.
-
-- **Location information** — Every token parsed by Syn is associated with a
-  `Span` that tracks line and column information back to the source of that
-  token. These spans allow a procedural macro to display detailed error messages
-  pointing to all the right places in the user's code. There is an example of
-  this below.
-
-- **Feature flags** — Functionality is aggressively feature gated so your
-  procedural macros enable only what they need, and do not pay in compile time
-  for all the rest.
-
-[`syn::File`]: https://docs.rs/syn/0.12/syn/struct.File.html
-[`syn::Item`]: https://docs.rs/syn/0.12/syn/enum.Item.html
-[`syn::Expr`]: https://docs.rs/syn/0.12/syn/enum.Expr.html
-[`syn::Type`]: https://docs.rs/syn/0.12/syn/enum.Type.html
-[`syn::DeriveInput`]: https://docs.rs/syn/0.12/syn/struct.DeriveInput.html
-
-If you get stuck with anything involving procedural macros in Rust I am happy to
-provide help even if the issue is not related to Syn. Please file a ticket in
-this repo.
-
-*Version requirement: Syn supports any compiler version back to Rust's very
-first support for procedural macros in Rust 1.15.0. Some features especially
-around error reporting are only available in newer compilers or on the nightly
-channel.*
-
-## Example of a custom derive
-
-The canonical custom derive using Syn looks like this. We write an ordinary Rust
-function tagged with a `proc_macro_derive` attribute and the name of the trait
-we are deriving. Any time that derive appears in the user's code, the Rust
-compiler passes their data structure as tokens into our macro. We get to execute
-arbitrary Rust code to figure out what to do with those tokens, then hand some
-tokens back to the compiler to compile into the user's crate.
-
-[`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html
-
-```toml
-[dependencies]
-syn = "0.12"
-quote = "0.4"
-
-[lib]
-proc-macro = true
-```
-
-```rust
-extern crate proc_macro;
-extern crate syn;
-
-#[macro_use]
-extern crate quote;
-
-use proc_macro::TokenStream;
-use syn::DeriveInput;
-
-#[proc_macro_derive(MyMacro)]
-pub fn my_macro(input: TokenStream) -> TokenStream {
-    // Parse the input tokens into a syntax tree
-    let input: DeriveInput = syn::parse(input).unwrap();
-
-    // Build the output, possibly using quasi-quotation
-    let expanded = quote! {
-        // ...
-    };
-
-    // Hand the output tokens back to the compiler
-    expanded.into()
-}
-```
-
-The [`heapsize`] example directory shows a complete working Macros 1.1
-implementation of a custom derive. It works on any Rust compiler \>=1.15.0. The
-example derives a `HeapSize` trait which computes an estimate of the amount of
-heap memory owned by a value.
-
-[`heapsize`]: examples/heapsize
-
-```rust
-pub trait HeapSize {
-    /// Total number of bytes of heap memory owned by `self`.
-    fn heap_size_of_children(&self) -> usize;
-}
-```
-
-The custom derive allows users to write `#[derive(HeapSize)]` on data structures
-in their program.
-
-```rust
-#[derive(HeapSize)]
-struct Demo<'a, T: ?Sized> {
-    a: Box<T>,
-    b: u8,
-    c: &'a str,
-    d: String,
-}
-```
-
-## Spans and error reporting
-
-The [`heapsize2`] example directory is an extension of the `heapsize` example
-that demonstrates some of the hygiene and error reporting properties of Macros
-2.0. This example currently requires a nightly Rust compiler \>=1.24.0-nightly
-but we are working to stabilize all of the APIs involved.
-
-[`heapsize2`]: examples/heapsize2
-
-The token-based procedural macro API provides great control over where the
-compiler's error messages are displayed in user code. Consider the error the
-user sees if one of their field types does not implement `HeapSize`.
-
-```rust
-#[derive(HeapSize)]
-struct Broken {
-    ok: String,
-    bad: std::thread::Thread,
-}
-```
-
-In the Macros 1.1 string-based procedural macro world, the resulting error would
-point unhelpfully to the invocation of the derive macro and not to the actual
-problematic field.
-
-```
-error[E0599]: no method named `heap_size_of_children` found for type `std::thread::Thread` in the current scope
- --> src/main.rs:4:10
-  |
-4 | #[derive(HeapSize)]
-  |          ^^^^^^^^
-```
-
-By tracking span information all the way through the expansion of a procedural
-macro as shown in the `heapsize2` example, token-based macros in Syn are able to
-trigger errors that directly pinpoint the source of the problem.
-
-```
-error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied
- --> src/main.rs:7:5
-  |
-7 |     bad: std::thread::Thread,
-  |     ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `std::thread::Thread`
-```
-
-## Parsing a custom syntax using combinators
-
-The [`lazy-static`] example directory shows the implementation of a
-`functionlike!(...)` procedural macro in which the input tokens are parsed using
-[`nom`]-style parser combinators.
-
-[`lazy-static`]: examples/lazy-static
-[`nom`]: https://github.com/Geal/nom
-
-The example reimplements the popular `lazy_static` crate from crates.io as a
-procedural macro.
-
-```
-lazy_static! {
-    static ref USERNAME: Regex = Regex::new("^[a-z0-9_-]{3,16}$").unwrap();
-}
-```
-
-The implementation shows how to trigger custom warnings and error messages on
-the macro input.
-
-```
-warning: come on, pick a more creative name
-  --> src/main.rs:10:16
-   |
-10 |     static ref FOO: String = "lazy_static".to_owned();
-   |                ^^^
-```
-
-## Debugging
-
-When developing a procedural macro it can be helpful to look at what the
-generated code looks like. Use `cargo rustc -- -Zunstable-options
---pretty=expanded` or the [`cargo expand`] subcommand.
-
-[`cargo expand`]: https://github.com/dtolnay/cargo-expand
-
-To show the expanded code for some crate that uses your procedural macro, run
-`cargo expand` from that crate. To show the expanded code for one of your own
-test cases, run `cargo expand --test the_test_case` where the last argument is
-the name of the test file without the `.rs` extension.
-
-This write-up by Brandon W Maister discusses debugging in more detail:
-[Debugging Rust's new Custom Derive system][debugging].
-
-[debugging]: https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/
-
-## Optional features
-
-Syn puts a lot of functionality behind optional features in order to optimize
-compile time for the most common use cases. The following features are
-available.
-
-- **`derive`** *(enabled by default)* — Data structures for representing the
-  possible input to a custom derive, including structs and enums and types.
-- **`full`** — Data structures for representing the syntax tree of all valid
-  Rust source code, including items and expressions.
-- **`parsing`** *(enabled by default)* — Ability to parse input tokens into a
-  syntax tree node of a chosen type.
-- **`printing`** *(enabled by default)* — Ability to print a syntax tree node as
-  tokens of Rust source code.
-- **`visit`** — Trait for traversing a syntax tree.
-- **`visit-mut`** — Trait for traversing and mutating in place a syntax tree.
-- **`fold`** — Trait for transforming an owned syntax tree.
-- **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree
-  types.
-- **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree
-  types.
-
-## Nightly features
-
-By default Syn uses the [`proc-macro2`] crate to emulate the nightly compiler's
-procedural macro API in a stable way that works all the way back to Rust 1.15.0.
-This shim makes it possible to write code without regard for whether the current
-compiler version supports the features we use.
-
-[`proc-macro2`]: https://github.com/alexcrichton/proc-macro2
-
-On a nightly compiler, to eliminate the stable shim and use the compiler's
-`proc-macro` directly, add `proc-macro2` to your Cargo.toml and set its
-`"nightly"` feature which bypasses the stable shim.
-
-```toml
-[dependencies]
-syn = "0.12"
-proc-macro2 = { version = "0.2", features = ["nightly"] }
-```
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-### Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
-be dual licensed as above, without any additional terms or conditions.
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/attr.rs
+++ /dev/null
@@ -1,571 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::*;
-use punctuated::Punctuated;
-
-use std::iter;
-
-use proc_macro2::{Delimiter, Spacing, TokenNode, TokenStream, TokenTree};
-
-#[cfg(feature = "extra-traits")]
-use std::hash::{Hash, Hasher};
-#[cfg(feature = "extra-traits")]
-use tt::TokenStreamHelper;
-
-ast_struct! {
-    /// An attribute like `#[repr(transparent)]`.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax
-    ///
-    /// Rust has six types of attributes.
-    ///
-    /// - Outer attributes like `#[repr(transparent)]`. These appear outside or
-    ///   in front of the item they describe.
-    /// - Inner attributes like `#![feature(proc_macro)]`. These appear inside
-    ///   of the item they describe, usually a module.
-    /// - Outer doc comments like `/// # Example`.
-    /// - Inner doc comments like `//! Please file an issue`.
-    /// - Outer block comments `/** # Example */`.
-    /// - Inner block comments `/*! Please file an issue */`.
-    ///
-    /// The `style` field of type `AttrStyle` distinguishes whether an attribute
-    /// is outer or inner. Doc comments and block comments are promoted to
-    /// attributes that have `is_sugared_doc` set to true, as this is how they
-    /// are processed by the compiler and by `macro_rules!` macros.
-    ///
-    /// The `path` field gives the possibly colon-delimited path against which
-    /// the attribute is resolved. It is equal to `"doc"` for desugared doc
-    /// comments. The `tts` field contains the rest of the attribute body as
-    /// tokens.
-    ///
-    /// ```text
-    /// #[derive(Copy)]      #[crate::precondition x < 5]
-    ///   ^^^^^^~~~~~~         ^^^^^^^^^^^^^^^^^^^ ~~~~~
-    ///    path  tts                   path         tts
-    /// ```
-    ///
-    /// Use the [`interpret_meta`] method to try parsing the tokens of an
-    /// attribute into the structured representation that is used by convention
-    /// across most Rust libraries.
-    ///
-    /// [`interpret_meta`]: #method.interpret_meta
-    pub struct Attribute #manual_extra_traits {
-        pub pound_token: Token![#],
-        pub style: AttrStyle,
-        pub bracket_token: token::Bracket,
-        pub path: Path,
-        pub tts: TokenStream,
-        pub is_sugared_doc: bool,
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-impl Eq for Attribute {}
-
-#[cfg(feature = "extra-traits")]
-impl PartialEq for Attribute {
-    fn eq(&self, other: &Self) -> bool {
-        self.style == other.style && self.pound_token == other.pound_token
-            && self.bracket_token == other.bracket_token && self.path == other.path
-            && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts)
-            && self.is_sugared_doc == other.is_sugared_doc
-    }
-}
-
-#[cfg(feature = "extra-traits")]
-impl Hash for Attribute {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.style.hash(state);
-        self.pound_token.hash(state);
-        self.bracket_token.hash(state);
-        self.path.hash(state);
-        TokenStreamHelper(&self.tts).hash(state);
-        self.is_sugared_doc.hash(state);
-    }
-}
-
-impl Attribute {
-    /// Parses the tokens after the path as a [`Meta`](enum.Meta.html) if
-    /// possible.
-    pub fn interpret_meta(&self) -> Option<Meta> {
-        let name = if self.path.segments.len() == 1 {
-            &self.path.segments.first().unwrap().value().ident
-        } else {
-            return None;
-        };
-
-        if self.tts.is_empty() {
-            return Some(Meta::Word(*name));
-        }
-
-        let tts = self.tts.clone().into_iter().collect::<Vec<_>>();
-
-        if tts.len() == 1 {
-            if let TokenNode::Group(Delimiter::Parenthesis, ref ts) = tts[0].kind {
-                let tokens = ts.clone().into_iter().collect::<Vec<_>>();
-                if let Some(nested_meta_items) = list_of_nested_meta_items_from_tokens(&tokens) {
-                    return Some(Meta::List(MetaList {
-                        paren_token: token::Paren(tts[0].span),
-                        ident: *name,
-                        nested: nested_meta_items,
-                    }));
-                }
-            }
-        }
-
-        if tts.len() == 2 {
-            if let TokenNode::Op('=', Spacing::Alone) = tts[0].kind {
-                if let TokenNode::Literal(ref lit) = tts[1].kind {
-                    if !lit.to_string().starts_with('/') {
-                        return Some(Meta::NameValue(MetaNameValue {
-                            ident: *name,
-                            eq_token: Token![=]([tts[0].span]),
-                            lit: Lit::new(lit.clone(), tts[1].span),
-                        }));
-                    }
-                } else if let TokenNode::Term(ref term) = tts[1].kind {
-                    match term.as_str() {
-                        v @ "true" | v @ "false" => {
-                            return Some(Meta::NameValue(MetaNameValue {
-                                ident: *name,
-                                eq_token: Token![=]([tts[0].span]),
-                                lit: Lit::Bool(LitBool { value: v == "true", span: tts[1].span }),
-                            }));
-                        },
-                        _ => {}
-                    }
-                }
-            }
-        }
-
-        None
-    }
-}
-
-fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> {
-    assert!(!tts.is_empty());
-
-    match tts[0].kind {
-        TokenNode::Literal(ref lit) => {
-            if lit.to_string().starts_with('/') {
-                None
-            } else {
-                let lit = Lit::new(lit.clone(), tts[0].span);
-                Some((NestedMeta::Literal(lit), &tts[1..]))
-            }
-        }
-
-        TokenNode::Term(sym) => {
-            let ident = Ident::new(sym.as_str(), tts[0].span);
-            if tts.len() >= 3 {
-                if let TokenNode::Op('=', Spacing::Alone) = tts[1].kind {
-                    if let TokenNode::Literal(ref lit) = tts[2].kind {
-                        if !lit.to_string().starts_with('/') {
-                            let pair = MetaNameValue {
-                                ident: Ident::new(sym.as_str(), tts[0].span),
-                                eq_token: Token![=]([tts[1].span]),
-                                lit: Lit::new(lit.clone(), tts[2].span),
-                            };
-                            return Some((Meta::NameValue(pair).into(), &tts[3..]));
-                        }
-                    } else if let TokenNode::Term(ref term) = tts[2].kind {
-                        match term.as_str() {
-                            v @ "true" | v @ "false" => {
-                                let pair = MetaNameValue {
-                                    ident: Ident::new(sym.as_str(), tts[0].span),
-                                    eq_token: Token![=]([tts[1].span]),
-                                    lit: Lit::Bool(LitBool { value: v == "true", span: tts[2].span }),
-                                };
-                                return Some((Meta::NameValue(pair).into(), &tts[3..]));
-                            },
-                            _ => {}
-                        }
-                    }
-                }
-            }
-
-            if tts.len() >= 2 {
-                if let TokenNode::Group(Delimiter::Parenthesis, ref inner_tts) = tts[1].kind {
-                    let inner_tts = inner_tts.clone().into_iter().collect::<Vec<_>>();
-                    return match list_of_nested_meta_items_from_tokens(&inner_tts) {
-                        Some(nested_meta_items) => {
-                            let list = MetaList {
-                                ident: ident,
-                                paren_token: token::Paren(tts[1].span),
-                                nested: nested_meta_items,
-                            };
-                            Some((Meta::List(list).into(), &tts[2..]))
-                        }
-
-                        None => None,
-                    };
-                }
-            }
-
-            Some((Meta::Word(ident).into(), &tts[1..]))
-        }
-
-        _ => None,
-    }
-}
-
-fn list_of_nested_meta_items_from_tokens(
-    mut tts: &[TokenTree],
-) -> Option<Punctuated<NestedMeta, Token![,]>> {
-    let mut nested_meta_items = Punctuated::new();
-    let mut first = true;
-
-    while !tts.is_empty() {
-        let prev_comma = if first {
-            first = false;
-            None
-        } else if let TokenNode::Op(',', Spacing::Alone) = tts[0].kind {
-            let tok = Token![,]([tts[0].span]);
-            tts = &tts[1..];
-            if tts.is_empty() {
-                break;
-            }
-            Some(tok)
-        } else {
-            return None;
-        };
-        let (nested, rest) = match nested_meta_item_from_tokens(tts) {
-            Some(pair) => pair,
-            None => return None,
-        };
-        if let Some(comma) = prev_comma {
-            nested_meta_items.push_punct(comma);
-        }
-        nested_meta_items.push_value(nested);
-        tts = rest;
-    }
-
-    Some(nested_meta_items)
-}
-
-ast_enum! {
-    /// Distinguishes between attributes that decorate an item and attributes
-    /// that are contained within an item.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Outer attributes
-    ///
-    /// - `#[repr(transparent)]`
-    /// - `/// # Example`
-    /// - `/** Please file an issue */`
-    ///
-    /// # Inner attributes
-    ///
-    /// - `#![feature(proc_macro)]`
-    /// - `//! # Example`
-    /// - `/*! Please file an issue */`
-    #[cfg_attr(feature = "clone-impls", derive(Copy))]
-    pub enum AttrStyle {
-        Outer,
-        Inner(Token![!]),
-    }
-}
-
-ast_enum_of_structs! {
-    /// Content of a compile-time structured attribute.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// ## Word
-    ///
-    /// A meta word is like the `test` in `#[test]`.
-    ///
-    /// ## List
-    ///
-    /// A meta list is like the `derive(Copy)` in `#[derive(Copy)]`.
-    ///
-    /// ## NameValue
-    ///
-    /// A name-value meta is like the `path = "..."` in `#[path =
-    /// "sys/windows.rs"]`.
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
-    pub enum Meta {
-        pub Word(Ident),
-        /// A structured list within an attribute, like `derive(Copy, Clone)`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub List(MetaList {
-            pub ident: Ident,
-            pub paren_token: token::Paren,
-            pub nested: Punctuated<NestedMeta, Token![,]>,
-        }),
-        /// A name-value pair within an attribute, like `feature = "nightly"`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub NameValue(MetaNameValue {
-            pub ident: Ident,
-            pub eq_token: Token![=],
-            pub lit: Lit,
-        }),
-    }
-}
-
-impl Meta {
-    /// Returns the identifier that begins this structured meta item.
-    ///
-    /// For example this would return the `test` in `#[test]`, the `derive` in
-    /// `#[derive(Copy)]`, and the `path` in `#[path = "sys/windows.rs"]`.
-    pub fn name(&self) -> Ident {
-        match *self {
-            Meta::Word(ref meta) => *meta,
-            Meta::List(ref meta) => meta.ident,
-            Meta::NameValue(ref meta) => meta.ident,
-        }
-    }
-}
-
-ast_enum_of_structs! {
-    /// Element of a compile-time attribute list.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    pub enum NestedMeta {
-        /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which
-        /// would be a nested `Meta::Word`.
-        pub Meta(Meta),
-
-        /// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`.
-        pub Literal(Lit),
-    }
-}
-
-pub trait FilterAttrs<'a> {
-    type Ret: Iterator<Item = &'a Attribute>;
-
-    fn outer(self) -> Self::Ret;
-    fn inner(self) -> Self::Ret;
-}
-
-impl<'a, T> FilterAttrs<'a> for T
-where
-    T: IntoIterator<Item = &'a Attribute>,
-{
-    type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>;
-
-    fn outer(self) -> Self::Ret {
-        fn is_outer(attr: &&Attribute) -> bool {
-            match attr.style {
-                AttrStyle::Outer => true,
-                _ => false,
-            }
-        }
-        self.into_iter().filter(is_outer)
-    }
-
-    fn inner(self) -> Self::Ret {
-        fn is_inner(attr: &&Attribute) -> bool {
-            match attr.style {
-                AttrStyle::Inner(_) => true,
-                _ => false,
-            }
-        }
-        self.into_iter().filter(is_inner)
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-    use buffer::Cursor;
-    use parse_error;
-    use synom::PResult;
-    use proc_macro2::{Literal, Spacing, Span, TokenNode, TokenTree};
-
-    fn eq(span: Span) -> TokenTree {
-        TokenTree {
-            span: span,
-            kind: TokenNode::Op('=', Spacing::Alone),
-        }
-    }
-
-    impl Attribute {
-        named!(pub parse_inner -> Self, alt!(
-            do_parse!(
-                pound: punct!(#) >>
-                bang: punct!(!) >>
-                path_and_tts: brackets!(tuple!(
-                    call!(Path::parse_mod_style),
-                    syn!(TokenStream)
-                )) >>
-                ({
-                    let (bracket, (path, tts)) = path_and_tts;
-
-                    Attribute {
-                        style: AttrStyle::Inner(bang),
-                        path: path,
-                        tts: tts,
-                        is_sugared_doc: false,
-                        pound_token: pound,
-                        bracket_token: bracket,
-                    }
-                })
-            )
-            |
-            map!(
-                call!(lit_doc_comment, Comment::Inner),
-                |lit| {
-                    let span = lit.span;
-                    Attribute {
-                        style: AttrStyle::Inner(<Token![!]>::new(span)),
-                        path: Ident::new("doc", span).into(),
-                        tts: vec![
-                            eq(span),
-                            lit,
-                        ].into_iter().collect(),
-                        is_sugared_doc: true,
-                        pound_token: <Token![#]>::new(span),
-                        bracket_token: token::Bracket(span),
-                    }
-                }
-            )
-        ));
-
-        named!(pub parse_outer -> Self, alt!(
-            do_parse!(
-                pound: punct!(#) >>
-                path_and_tts: brackets!(tuple!(
-                    call!(Path::parse_mod_style),
-                    syn!(TokenStream)
-                )) >>
-                ({
-                    let (bracket, (path, tts)) = path_and_tts;
-
-                    Attribute {
-                        style: AttrStyle::Outer,
-                        path: path,
-                        tts: tts,
-                        is_sugared_doc: false,
-                        pound_token: pound,
-                        bracket_token: bracket,
-                    }
-                })
-            )
-            |
-            map!(
-                call!(lit_doc_comment, Comment::Outer),
-                |lit| {
-                    let span = lit.span;
-                    Attribute {
-                        style: AttrStyle::Outer,
-                        path: Ident::new("doc", span).into(),
-                        tts: vec![
-                            eq(span),
-                            lit,
-                        ].into_iter().collect(),
-                        is_sugared_doc: true,
-                        pound_token: <Token![#]>::new(span),
-                        bracket_token: token::Bracket(span),
-                    }
-                }
-            )
-        ));
-    }
-
-    enum Comment {
-        Inner,
-        Outer,
-    }
-
-    fn lit_doc_comment(input: Cursor, style: Comment) -> PResult<TokenTree> {
-        match input.literal() {
-            Some((span, lit, rest)) => {
-                let string = lit.to_string();
-                let ok = match style {
-                    Comment::Inner => string.starts_with("//!") || string.starts_with("/*!"),
-                    Comment::Outer => string.starts_with("///") || string.starts_with("/**"),
-                };
-                if ok {
-                    Ok((
-                        TokenTree {
-                            span: span,
-                            kind: TokenNode::Literal(Literal::string(&string)),
-                        },
-                        rest,
-                    ))
-                } else {
-                    parse_error()
-                }
-            }
-            _ => parse_error(),
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use quote::{ToTokens, Tokens};
-    use proc_macro2::Literal;
-
-    impl ToTokens for Attribute {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            // If this was a sugared doc, emit it in its original form instead of `#[doc = "..."]`
-            if self.is_sugared_doc {
-                if let Some(Meta::NameValue(ref pair)) = self.interpret_meta() {
-                    if pair.ident == "doc" {
-                        if let Lit::Str(ref comment) = pair.lit {
-                            tokens.append(TokenTree {
-                                span: comment.span,
-                                kind: TokenNode::Literal(Literal::doccomment(&comment.value())),
-                            });
-                            return;
-                        }
-                    }
-                }
-            }
-
-            self.pound_token.to_tokens(tokens);
-            if let AttrStyle::Inner(ref b) = self.style {
-                b.to_tokens(tokens);
-            }
-            self.bracket_token.surround(tokens, |tokens| {
-                self.path.to_tokens(tokens);
-                self.tts.to_tokens(tokens);
-            });
-        }
-    }
-
-    impl ToTokens for MetaList {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.ident.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.nested.to_tokens(tokens);
-            })
-        }
-    }
-
-    impl ToTokens for MetaNameValue {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.ident.to_tokens(tokens);
-            self.eq_token.to_tokens(tokens);
-            self.lit.to_tokens(tokens);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/buffer.rs
+++ /dev/null
@@ -1,467 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A stably addressed token buffer supporting efficient traversal based on a
-//! cheaply copyable cursor.
-//!
-//! The [`Synom`] trait is implemented for syntax tree types that can be parsed
-//! from one of these token cursors.
-//!
-//! [`Synom`]: ../synom/trait.Synom.html
-//!
-//! *This module is available if Syn is built with the `"parsing"` feature.*
-//!
-//! # Example
-//!
-//! This example shows a basic token parser for parsing a token stream without
-//! using Syn's parser combinator macros.
-//!
-//! ```
-//! #![feature(proc_macro)]
-//!
-//! extern crate syn;
-//! extern crate proc_macro;
-//!
-//! #[macro_use]
-//! extern crate quote;
-//!
-//! use syn::{token, ExprTuple};
-//! use syn::buffer::{Cursor, TokenBuffer};
-//! use syn::spanned::Spanned;
-//! use syn::synom::Synom;
-//! use proc_macro::{Diagnostic, Span, TokenStream};
-//!
-//! /// A basic token parser for parsing a token stream without using Syn's
-//! /// parser combinator macros.
-//! pub struct Parser<'a> {
-//!     cursor: Cursor<'a>,
-//! }
-//!
-//! impl<'a> Parser<'a> {
-//!     pub fn new(cursor: Cursor<'a>) -> Self {
-//!         Parser { cursor }
-//!     }
-//!
-//!     pub fn current_span(&self) -> Span {
-//!         self.cursor.span().unstable()
-//!     }
-//!
-//!     pub fn parse<T: Synom>(&mut self) -> Result<T, Diagnostic> {
-//!         let (val, rest) = T::parse(self.cursor)
-//!             .map_err(|e| match T::description() {
-//!                 Some(desc) => {
-//!                     self.current_span().error(format!("{}: expected {}", e, desc))
-//!                 }
-//!                 None => {
-//!                     self.current_span().error(e.to_string())
-//!                 }
-//!             })?;
-//!
-//!         self.cursor = rest;
-//!         Ok(val)
-//!     }
-//!
-//!     pub fn expect_eof(&mut self) -> Result<(), Diagnostic> {
-//!         if !self.cursor.eof() {
-//!             return Err(self.current_span().error("trailing characters; expected eof"));
-//!         }
-//!
-//!         Ok(())
-//!     }
-//! }
-//!
-//! fn eval(input: TokenStream) -> Result<TokenStream, Diagnostic> {
-//!     let buffer = TokenBuffer::new(input);
-//!     let mut parser = Parser::new(buffer.begin());
-//!
-//!     // Parse some syntax tree types out of the input tokens. In this case we
-//!     // expect something like:
-//!     //
-//!     //     (a, b, c) = (1, 2, 3)
-//!     let a = parser.parse::<ExprTuple>()?;
-//!     parser.parse::<token::Eq>()?;
-//!     let b = parser.parse::<ExprTuple>()?;
-//!     parser.expect_eof()?;
-//!
-//!     // Perform some validation and report errors.
-//!     let (a_len, b_len) = (a.elems.len(), b.elems.len());
-//!     if a_len != b_len {
-//!         let diag = b.span().unstable()
-//!             .error(format!("expected {} element(s), got {}", a_len, b_len))
-//!             .span_note(a.span().unstable(), "because of this");
-//!
-//!         return Err(diag);
-//!     }
-//!
-//!     // Build the output tokens.
-//!     let out = quote! {
-//!         println!("All good! Received two tuples of size {}", #a_len);
-//!     };
-//!
-//!     Ok(out.into())
-//! }
-//! #
-//! # extern crate proc_macro2;
-//! #
-//! # // This method exists on proc_macro2::Span but is behind the "nightly"
-//! # // feature.
-//! # trait ToUnstableSpan {
-//! #     fn unstable(&self) -> Span;
-//! # }
-//! #
-//! # impl ToUnstableSpan for proc_macro2::Span {
-//! #     fn unstable(&self) -> Span {
-//! #         unimplemented!()
-//! #     }
-//! # }
-//! #
-//! # fn main() {}
-//! ```
-
-// This module is heavily commented as it contains the only unsafe code in Syn,
-// and caution should be used when editing it. The public-facing interface is
-// 100% safe but the implementation is fragile internally.
-
-use proc_macro as pm;
-use proc_macro2::{Delimiter, Literal, Spacing, Span, Term, TokenNode, TokenStream, TokenTree};
-
-use std::ptr;
-use std::marker::PhantomData;
-
-#[cfg(synom_verbose_trace)]
-use std::fmt::{self, Debug};
-
-/// Internal type which is used instead of `TokenTree` to represent a token tree
-/// within a `TokenBuffer`.
-enum Entry {
-    // Mimicking types from proc-macro.
-    Group(Span, Delimiter, TokenBuffer),
-    Term(Span, Term),
-    Op(Span, char, Spacing),
-    Literal(Span, Literal),
-    // End entries contain a raw pointer to the entry from the containing
-    // token tree, or null if this is the outermost level.
-    End(*const Entry),
-}
-
-/// A buffer that can be efficiently traversed multiple times, unlike
-/// `TokenStream` which requires a deep copy in order to traverse more than
-/// once.
-///
-/// See the [module documentation] for an example of `TokenBuffer` in action.
-///
-/// [module documentation]: index.html
-///
-/// *This type is available if Syn is built with the `"parsing"` feature.*
-pub struct TokenBuffer {
-    // NOTE: Do not derive clone on this - there are raw pointers inside which
-    // will be messed up. Moving the `TokenBuffer` itself is safe as the actual
-    // backing slices won't be moved.
-    data: Box<[Entry]>,
-}
-
-impl TokenBuffer {
-    // NOTE: DO NOT MUTATE THE `Vec` RETURNED FROM THIS FUNCTION ONCE IT
-    // RETURNS, THE ADDRESS OF ITS BACKING MEMORY MUST REMAIN STABLE.
-    fn inner_new(stream: TokenStream, up: *const Entry) -> TokenBuffer {
-        // Build up the entries list, recording the locations of any Groups
-        // in the list to be processed later.
-        let mut entries = Vec::new();
-        let mut seqs = Vec::new();
-        for tt in stream {
-            match tt.kind {
-                TokenNode::Term(sym) => {
-                    entries.push(Entry::Term(tt.span, sym));
-                }
-                TokenNode::Op(chr, ok) => {
-                    entries.push(Entry::Op(tt.span, chr, ok));
-                }
-                TokenNode::Literal(lit) => {
-                    entries.push(Entry::Literal(tt.span, lit));
-                }
-                TokenNode::Group(delim, seq_stream) => {
-                    // Record the index of the interesting entry, and store an
-                    // `End(null)` there temporarially.
-                    seqs.push((entries.len(), tt.span, delim, seq_stream));
-                    entries.push(Entry::End(ptr::null()));
-                }
-            }
-        }
-        // Add an `End` entry to the end with a reference to the enclosing token
-        // stream which was passed in.
-        entries.push(Entry::End(up));
-
-        // NOTE: This is done to ensure that we don't accidentally modify the
-        // length of the backing buffer. The backing buffer must remain at a
-        // constant address after this point, as we are going to store a raw
-        // pointer into it.
-        let mut entries = entries.into_boxed_slice();
-        for (idx, span, delim, seq_stream) in seqs {
-            // We know that this index refers to one of the temporary
-            // `End(null)` entries, and we know that the last entry is
-            // `End(up)`, so the next index is also valid.
-            let seq_up = &entries[idx + 1] as *const Entry;
-
-            // The end entry stored at the end of this Entry::Group should
-            // point to the Entry which follows the Group in the list.
-            let inner = Self::inner_new(seq_stream, seq_up);
-            entries[idx] = Entry::Group(span, delim, inner);
-        }
-
-        TokenBuffer { data: entries }
-    }
-
-    /// Creates a `TokenBuffer` containing all the tokens from the input
-    /// `TokenStream`.
-    pub fn new(stream: pm::TokenStream) -> TokenBuffer {
-        Self::new2(stream.into())
-    }
-
-    /// Creates a `TokenBuffer` containing all the tokens from the input
-    /// `TokenStream`.
-    pub fn new2(stream: TokenStream) -> TokenBuffer {
-        Self::inner_new(stream, ptr::null())
-    }
-
-    /// Creates a cursor referencing the first token in the buffer and able to
-    /// traverse until the end of the buffer.
-    pub fn begin(&self) -> Cursor {
-        unsafe { Cursor::create(&self.data[0], &self.data[self.data.len() - 1]) }
-    }
-}
-
-/// A cheaply copyable cursor into a `TokenBuffer`.
-///
-/// This cursor holds a shared reference into the immutable data which is used
-/// internally to represent a `TokenStream`, and can be efficiently manipulated
-/// and copied around.
-///
-/// An empty `Cursor` can be created directly, or one may create a `TokenBuffer`
-/// object and get a cursor to its first token with `begin()`.
-///
-/// Two cursors are equal if they have the same location in the same input
-/// stream, and have the same scope.
-///
-/// See the [module documentation] for an example of a `Cursor` in action.
-///
-/// [module documentation]: index.html
-///
-/// *This type is available if Syn is built with the `"parsing"` feature.*
-#[derive(Copy, Clone, Eq, PartialEq)]
-pub struct Cursor<'a> {
-    /// The current entry which the `Cursor` is pointing at.
-    ptr: *const Entry,
-    /// This is the only `Entry::End(..)` object which this cursor is allowed to
-    /// point at. All other `End` objects are skipped over in `Cursor::create`.
-    scope: *const Entry,
-    /// This uses the &'a reference which guarantees that these pointers are
-    /// still valid.
-    marker: PhantomData<&'a Entry>,
-}
-
-impl<'a> Cursor<'a> {
-    /// Creates a cursor referencing a static empty TokenStream.
-    pub fn empty() -> Self {
-        // It's safe in this situation for us to put an `Entry` object in global
-        // storage, despite it not actually being safe to send across threads
-        // (`Term` is a reference into a thread-local table). This is because
-        // this entry never includes a `Term` object.
-        //
-        // This wrapper struct allows us to break the rules and put a `Sync`
-        // object in global storage.
-        struct UnsafeSyncEntry(Entry);
-        unsafe impl Sync for UnsafeSyncEntry {}
-        static EMPTY_ENTRY: UnsafeSyncEntry = UnsafeSyncEntry(Entry::End(0 as *const Entry));
-
-        Cursor {
-            ptr: &EMPTY_ENTRY.0,
-            scope: &EMPTY_ENTRY.0,
-            marker: PhantomData,
-        }
-    }
-
-    /// This create method intelligently exits non-explicitly-entered
-    /// `None`-delimited scopes when the cursor reaches the end of them,
-    /// allowing for them to be treated transparently.
-    unsafe fn create(mut ptr: *const Entry, scope: *const Entry) -> Self {
-        // NOTE: If we're looking at a `End(..)`, we want to advance the cursor
-        // past it, unless `ptr == scope`, which means that we're at the edge of
-        // our cursor's scope. We should only have `ptr != scope` at the exit
-        // from None-delimited groups entered with `ignore_none`.
-        while let Entry::End(exit) = *ptr {
-            if ptr == scope {
-                break;
-            }
-            ptr = exit;
-        }
-
-        Cursor {
-            ptr: ptr,
-            scope: scope,
-            marker: PhantomData,
-        }
-    }
-
-    /// Get the current entry.
-    fn entry(self) -> &'a Entry {
-        unsafe { &*self.ptr }
-    }
-
-    /// Bump the cursor to point at the next token after the current one. This
-    /// is undefined behavior if the cursor is currently looking at an
-    /// `Entry::End`.
-    unsafe fn bump(self) -> Cursor<'a> {
-        Cursor::create(self.ptr.offset(1), self.scope)
-    }
-
-    /// If the cursor is looking at a `None`-delimited group, move it to look at
-    /// the first token inside instead. If the group is empty, this will move
-    /// the cursor past the `None`-delimited group.
-    ///
-    /// WARNING: This mutates its argument.
-    fn ignore_none(&mut self) {
-        if let Entry::Group(_, Delimiter::None, ref buf) = *self.entry() {
-            // NOTE: We call `Cursor::create` here to make sure that situations
-            // where we should immediately exit the span after entering it are
-            // handled correctly.
-            unsafe {
-                *self = Cursor::create(&buf.data[0], self.scope);
-            }
-        }
-    }
-
-    /// Checks whether the cursor is currently pointing at the end of its valid
-    /// scope.
-    #[inline]
-    pub fn eof(self) -> bool {
-        // We're at eof if we're at the end of our scope.
-        self.ptr == self.scope
-    }
-
-    /// If the cursor is pointing at a `Group` with the given delimiter, returns
-    /// a cursor into that group and one pointing to the next `TokenTree`.
-    pub fn group(mut self, delim: Delimiter) -> Option<(Cursor<'a>, Span, Cursor<'a>)> {
-        // If we're not trying to enter a none-delimited group, we want to
-        // ignore them. We have to make sure to _not_ ignore them when we want
-        // to enter them, of course. For obvious reasons.
-        if delim != Delimiter::None {
-            self.ignore_none();
-        }
-
-        if let Entry::Group(span, group_delim, ref buf) = *self.entry() {
-            if group_delim == delim {
-                return Some((buf.begin(), span, unsafe { self.bump() }));
-            }
-        }
-
-        None
-    }
-
-    /// If the cursor is pointing at a `Term`, returns it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn term(mut self) -> Option<(Span, Term, Cursor<'a>)> {
-        self.ignore_none();
-        match *self.entry() {
-            Entry::Term(span, term) => Some((span, term, unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// If the cursor is pointing at an `Op`, returns it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn op(mut self) -> Option<(Span, char, Spacing, Cursor<'a>)> {
-        self.ignore_none();
-        match *self.entry() {
-            Entry::Op(span, op, spacing) => Some((span, op, spacing, unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// If the cursor is pointing at a `Literal`, return it along with a cursor
-    /// pointing at the next `TokenTree`.
-    pub fn literal(mut self) -> Option<(Span, Literal, Cursor<'a>)> {
-        self.ignore_none();
-        match *self.entry() {
-            Entry::Literal(span, ref lit) => Some((span, lit.clone(), unsafe { self.bump() })),
-            _ => None,
-        }
-    }
-
-    /// Copies all remaining tokens visible from this cursor into a
-    /// `TokenStream`.
-    pub fn token_stream(self) -> TokenStream {
-        let mut tts = Vec::new();
-        let mut cursor = self;
-        while let Some((tt, rest)) = cursor.token_tree() {
-            tts.push(tt);
-            cursor = rest;
-        }
-        tts.into_iter().collect()
-    }
-
-    /// If the cursor is pointing at a `TokenTree`, returns it along with a
-    /// cursor pointing at the next `TokenTree`.
-    ///
-    /// Returns `None` if the cursor has reached the end of its stream.
-    ///
-    /// This method does not treat `None`-delimited groups as transparent, and
-    /// will return a `Group(None, ..)` if the cursor is looking at one.
-    pub fn token_tree(self) -> Option<(TokenTree, Cursor<'a>)> {
-        let tree = match *self.entry() {
-            Entry::Group(span, delim, ref buf) => {
-                let stream = buf.begin().token_stream();
-                TokenTree {
-                    span: span,
-                    kind: TokenNode::Group(delim, stream),
-                }
-            }
-            Entry::Literal(span, ref lit) => TokenTree {
-                span: span,
-                kind: TokenNode::Literal(lit.clone()),
-            },
-            Entry::Term(span, sym) => TokenTree {
-                span: span,
-                kind: TokenNode::Term(sym),
-            },
-            Entry::Op(span, chr, spacing) => TokenTree {
-                span: span,
-                kind: TokenNode::Op(chr, spacing),
-            },
-            Entry::End(..) => {
-                return None;
-            }
-        };
-
-        Some((tree, unsafe { self.bump() }))
-    }
-
-    /// Returns the `Span` of the current token, or `Span::call_site()` if this
-    /// cursor points to eof.
-    pub fn span(self) -> Span {
-        match *self.entry() {
-            Entry::Group(span, ..)
-            | Entry::Literal(span, ..)
-            | Entry::Term(span, ..)
-            | Entry::Op(span, ..) => span,
-            Entry::End(..) => Span::call_site(),
-        }
-    }
-}
-
-// We do a custom implementation for `Debug` as the default implementation is
-// pretty useless.
-#[cfg(synom_verbose_trace)]
-impl<'a> Debug for Cursor<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // Print what the cursor is currently looking at.
-        // This will look like Cursor("some remaining tokens here")
-        f.debug_tuple("Cursor")
-            .field(&self.token_stream().to_string())
-            .finish()
-    }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/data.rs
+++ /dev/null
@@ -1,388 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::*;
-use punctuated::Punctuated;
-
-ast_struct! {
-    /// An enum variant.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    pub struct Variant {
-        /// Attributes tagged on the variant.
-        pub attrs: Vec<Attribute>,
-
-        /// Name of the variant.
-        pub ident: Ident,
-
-        /// Content stored in the variant.
-        pub fields: Fields,
-
-        /// Explicit discriminant: `Variant = 1`
-        pub discriminant: Option<(Token![=], Expr)>,
-    }
-}
-
-ast_enum_of_structs! {
-    /// Data stored within an enum variant or struct.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
-    pub enum Fields {
-        /// Named fields of a struct or struct variant such as `Point { x: f64,
-        /// y: f64 }`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub Named(FieldsNamed {
-            pub brace_token: token::Brace,
-            pub named: Punctuated<Field, Token![,]>,
-        }),
-
-        /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub Unnamed(FieldsUnnamed {
-            pub paren_token: token::Paren,
-            pub unnamed: Punctuated<Field, Token![,]>,
-        }),
-
-        /// Unit struct or unit variant such as `None`.
-        pub Unit,
-    }
-}
-
-impl Fields {
-    /// Get an iterator over the [`Field`] items in this object. This iterator
-    /// can be used to iterate over a named or unnamed struct or variant's
-    /// fields uniformly.
-    ///
-    /// [`Field`]: struct.Field.html
-    pub fn iter(&self) -> punctuated::Iter<Field, Token![,]> {
-        match *self {
-            Fields::Unit => punctuated::Iter::private_empty(),
-            Fields::Named(ref f) => f.named.iter(),
-            Fields::Unnamed(ref f) => f.unnamed.iter(),
-        }
-    }
-}
-
-impl<'a> IntoIterator for &'a Fields {
-    type Item = &'a Field;
-    type IntoIter = punctuated::Iter<'a, Field, Token![,]>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.iter()
-    }
-}
-
-ast_struct! {
-    /// A field of a struct or enum variant.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    pub struct Field {
-        /// Attributes tagged on the field.
-        pub attrs: Vec<Attribute>,
-
-        /// Visibility of the field.
-        pub vis: Visibility,
-
-        /// Name of the field, if any.
-        ///
-        /// Fields of tuple structs have no names.
-        pub ident: Option<Ident>,
-
-        pub colon_token: Option<Token![:]>,
-
-        /// Type of the field.
-        pub ty: Type,
-    }
-}
-
-ast_enum_of_structs! {
-    /// The visibility level of an item: inherited or `pub` or
-    /// `pub(restricted)`.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
-    pub enum Visibility {
-        /// A public visibility level: `pub`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub Public(VisPublic {
-            pub pub_token: Token![pub],
-        }),
-
-        /// A crate-level visibility: `pub(crate)`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub Crate(VisCrate {
-            pub pub_token: Token![pub],
-            pub paren_token: token::Paren,
-            pub crate_token: Token![crate],
-        }),
-
-        /// A visibility level restricted to some path: `pub(self)` or
-        /// `pub(super)` or `pub(in some::module)`.
-        ///
-        /// *This type is available if Syn is built with the `"derive"` or
-        /// `"full"` feature.*
-        pub Restricted(VisRestricted {
-            pub pub_token: Token![pub],
-            pub paren_token: token::Paren,
-            pub in_token: Option<Token![in]>,
-            pub path: Box<Path>,
-        }),
-
-        /// An inherited visibility, which usually means private.
-        pub Inherited,
-    }
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-
-    use synom::Synom;
-
-    impl Synom for Variant {
-        named!(parse -> Self, do_parse!(
-            attrs: many0!(Attribute::parse_outer) >>
-            id: syn!(Ident) >>
-            fields: alt!(
-                syn!(FieldsNamed) => { Fields::Named }
-                |
-                syn!(FieldsUnnamed) => { Fields::Unnamed }
-                |
-                epsilon!() => { |_| Fields::Unit }
-            ) >>
-            disr: option!(tuple!(punct!(=), syn!(Expr))) >>
-            (Variant {
-                ident: id,
-                attrs: attrs,
-                fields: fields,
-                discriminant: disr,
-            })
-        ));
-
-        fn description() -> Option<&'static str> {
-            Some("enum variant")
-        }
-    }
-
-    impl Synom for FieldsNamed {
-        named!(parse -> Self, map!(
-            braces!(call!(Punctuated::parse_terminated_with, Field::parse_named)),
-            |(brace, fields)| FieldsNamed {
-                brace_token: brace,
-                named: fields,
-            }
-        ));
-
-        fn description() -> Option<&'static str> {
-            Some("named fields in a struct or struct variant")
-        }
-    }
-
-    impl Synom for FieldsUnnamed {
-        named!(parse -> Self, map!(
-            parens!(call!(Punctuated::parse_terminated_with, Field::parse_unnamed)),
-            |(paren, fields)| FieldsUnnamed {
-                paren_token: paren,
-                unnamed: fields,
-            }
-        ));
-
-        fn description() -> Option<&'static str> {
-            Some("unnamed fields in a tuple struct or tuple variant")
-        }
-    }
-
-    impl Field {
-        named!(pub parse_named -> Self, do_parse!(
-            attrs: many0!(Attribute::parse_outer) >>
-            vis: syn!(Visibility) >>
-            id: syn!(Ident) >>
-            colon: punct!(:) >>
-            ty: syn!(Type) >>
-            (Field {
-                ident: Some(id),
-                vis: vis,
-                attrs: attrs,
-                ty: ty,
-                colon_token: Some(colon),
-            })
-        ));
-
-        named!(pub parse_unnamed -> Self, do_parse!(
-            attrs: many0!(Attribute::parse_outer) >>
-            vis: syn!(Visibility) >>
-            ty: syn!(Type) >>
-            (Field {
-                ident: None,
-                colon_token: None,
-                vis: vis,
-                attrs: attrs,
-                ty: ty,
-            })
-        ));
-    }
-
-    impl Synom for Visibility {
-        named!(parse -> Self, alt!(
-            do_parse!(
-                pub_token: keyword!(pub) >>
-                other: parens!(keyword!(crate)) >>
-                (Visibility::Crate(VisCrate {
-                    pub_token: pub_token,
-                    paren_token: other.0,
-                    crate_token: other.1,
-                }))
-            )
-            |
-            do_parse!(
-                pub_token: keyword!(pub) >>
-                other: parens!(keyword!(self)) >>
-                (Visibility::Restricted(VisRestricted {
-                    pub_token: pub_token,
-                    paren_token: other.0,
-                    in_token: None,
-                    path: Box::new(other.1.into()),
-                }))
-            )
-            |
-            do_parse!(
-                pub_token: keyword!(pub) >>
-                other: parens!(keyword!(super)) >>
-                (Visibility::Restricted(VisRestricted {
-                    pub_token: pub_token,
-                    paren_token: other.0,
-                    in_token: None,
-                    path: Box::new(other.1.into()),
-                }))
-            )
-            |
-            do_parse!(
-                pub_token: keyword!(pub) >>
-                other: parens!(do_parse!(
-                    in_tok: keyword!(in) >>
-                    restricted: call!(Path::parse_mod_style) >>
-                    (in_tok, restricted)
-                )) >>
-                (Visibility::Restricted(VisRestricted {
-                    pub_token: pub_token,
-                    paren_token: other.0,
-                    in_token: Some((other.1).0),
-                    path: Box::new((other.1).1),
-                }))
-            )
-            |
-            keyword!(pub) => { |tok| {
-                Visibility::Public(VisPublic {
-                    pub_token: tok,
-                })
-            } }
-            |
-            epsilon!() => { |_| Visibility::Inherited }
-        ));
-
-        fn description() -> Option<&'static str> {
-            Some("visibility qualifier such as `pub`")
-        }
-    }
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use quote::{ToTokens, Tokens};
-
-    impl ToTokens for Variant {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            tokens.append_all(&self.attrs);
-            self.ident.to_tokens(tokens);
-            self.fields.to_tokens(tokens);
-            if let Some((ref eq_token, ref disc)) = self.discriminant {
-                eq_token.to_tokens(tokens);
-                disc.to_tokens(tokens);
-            }
-        }
-    }
-
-    impl ToTokens for FieldsNamed {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.brace_token.surround(tokens, |tokens| {
-                self.named.to_tokens(tokens);
-            });
-        }
-    }
-
-    impl ToTokens for FieldsUnnamed {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.paren_token.surround(tokens, |tokens| {
-                self.unnamed.to_tokens(tokens);
-            });
-        }
-    }
-
-    impl ToTokens for Field {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            tokens.append_all(&self.attrs);
-            self.vis.to_tokens(tokens);
-            if let Some(ref ident) = self.ident {
-                ident.to_tokens(tokens);
-                TokensOrDefault(&self.colon_token).to_tokens(tokens);
-            }
-            self.ty.to_tokens(tokens);
-        }
-    }
-
-    impl ToTokens for VisPublic {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.pub_token.to_tokens(tokens)
-        }
-    }
-
-    impl ToTokens for VisCrate {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.pub_token.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                self.crate_token.to_tokens(tokens);
-            })
-        }
-    }
-
-    impl ToTokens for VisRestricted {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            self.pub_token.to_tokens(tokens);
-            self.paren_token.surround(tokens, |tokens| {
-                // XXX: If we have a path which is not "self" or "super",
-                // automatically add the "in" token.
-                self.in_token.to_tokens(tokens);
-                self.path.to_tokens(tokens);
-            });
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/derive.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::*;
-use punctuated::Punctuated;
-
-ast_struct! {
-    /// Data structure sent to a `proc_macro_derive` macro.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` feature.*
-    pub struct DeriveInput {
-        /// Attributes tagged on the whole struct or enum.
-        pub attrs: Vec<Attribute>,
-
-        /// Visibility of the struct or enum.
-        pub vis: Visibility,
-
-        /// Name of the struct or enum.
-        pub ident: Ident,
-
-        /// Generics required to complete the definition.
-        pub generics: Generics,
-
-        /// Data within the struct or enum.
-        pub data: Data,
-    }
-}
-
-ast_enum_of_structs! {
-    /// The storage of a struct, enum or union data structure.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` feature.*
-    ///
-    /// # Syntax tree enum
-    ///
-    /// This type is a [syntax tree enum].
-    ///
-    /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums
-    pub enum Data {
-        /// A struct input to a `proc_macro_derive` macro.
-        ///
-        /// *This type is available if Syn is built with the `"derive"`
-        /// feature.*
-        pub Struct(DataStruct {
-            pub struct_token: Token![struct],
-            pub fields: Fields,
-            pub semi_token: Option<Token![;]>,
-        }),
-
-        /// An enum input to a `proc_macro_derive` macro.
-        ///
-        /// *This type is available if Syn is built with the `"derive"`
-        /// feature.*
-        pub Enum(DataEnum {
-            pub enum_token: Token![enum],
-            pub brace_token: token::Brace,
-            pub variants: Punctuated<Variant, Token![,]>,
-        }),
-
-        /// A tagged union input to a `proc_macro_derive` macro.
-        ///
-        /// *This type is available if Syn is built with the `"derive"`
-        /// feature.*
-        pub Union(DataUnion {
-            pub union_token: Token![union],
-            pub fields: FieldsNamed,
-        }),
-    }
-
-    do_not_generate_to_tokens
-}
-
-#[cfg(feature = "parsing")]
-pub mod parsing {
-    use super::*;
-
-    use synom::Synom;
-
-    impl Synom for DeriveInput {
-        named!(parse -> Self, do_parse!(
-            attrs: many0!(Attribute::parse_outer) >>
-            vis: syn!(Visibility) >>
-            which: alt!(
-                keyword!(struct) => { Ok }
-                |
-                keyword!(enum) => { Err }
-            ) >>
-            id: syn!(Ident) >>
-            generics: syn!(Generics) >>
-            item: switch!(value!(which),
-                Ok(s) => map!(data_struct, move |(wh, fields, semi)| DeriveInput {
-                    ident: id,
-                    vis: vis,
-                    attrs: attrs,
-                    generics: Generics {
-                        where_clause: wh,
-                        .. generics
-                    },
-                    data: Data::Struct(DataStruct {
-                        struct_token: s,
-                        fields: fields,
-                        semi_token: semi,
-                    }),
-                })
-                |
-                Err(e) => map!(data_enum, move |(wh, brace, variants)| DeriveInput {
-                    ident: id,
-                    vis: vis,
-                    attrs: attrs,
-                    generics: Generics {
-                        where_clause: wh,
-                        .. generics
-                    },
-                    data: Data::Enum(DataEnum {
-                        variants: variants,
-                        brace_token: brace,
-                        enum_token: e,
-                    }),
-                })
-            ) >>
-            (item)
-        ));
-
-        fn description() -> Option<&'static str> {
-            Some("derive input")
-        }
-    }
-
-    named!(data_struct -> (Option<WhereClause>, Fields, Option<Token![;]>), alt!(
-        do_parse!(
-            wh: option!(syn!(WhereClause)) >>
-            fields: syn!(FieldsNamed) >>
-            (wh, Fields::Named(fields), None)
-        )
-        |
-        do_parse!(
-            fields: syn!(FieldsUnnamed) >>
-            wh: option!(syn!(WhereClause)) >>
-            semi: punct!(;) >>
-            (wh, Fields::Unnamed(fields), Some(semi))
-        )
-        |
-        do_parse!(
-            wh: option!(syn!(WhereClause)) >>
-            semi: punct!(;) >>
-            (wh, Fields::Unit, Some(semi))
-        )
-    ));
-
-    named!(data_enum -> (Option<WhereClause>, token::Brace, Punctuated<Variant, Token![,]>), do_parse!(
-        wh: option!(syn!(WhereClause)) >>
-        data: braces!(Punctuated::parse_terminated) >>
-        (wh, data.0, data.1)
-    ));
-}
-
-#[cfg(feature = "printing")]
-mod printing {
-    use super::*;
-    use attr::FilterAttrs;
-    use quote::{ToTokens, Tokens};
-
-    impl ToTokens for DeriveInput {
-        fn to_tokens(&self, tokens: &mut Tokens) {
-            for attr in self.attrs.outer() {
-                attr.to_tokens(tokens);
-            }
-            self.vis.to_tokens(tokens);
-            match self.data {
-                Data::Struct(ref d) => d.struct_token.to_tokens(tokens),
-                Data::Enum(ref d) => d.enum_token.to_tokens(tokens),
-                Data::Union(ref d) => d.union_token.to_tokens(tokens),
-            }
-            self.ident.to_tokens(tokens);
-            self.generics.to_tokens(tokens);
-            match self.data {
-                Data::Struct(ref data) => match data.fields {
-                    Fields::Named(ref fields) => {
-                        self.generics.where_clause.to_tokens(tokens);
-                        fields.to_tokens(tokens);
-                    }
-                    Fields::Unnamed(ref fields) => {
-                        fields.to_tokens(tokens);
-                        self.generics.where_clause.to_tokens(tokens);
-                        TokensOrDefault(&data.semi_token).to_tokens(tokens);
-                    }
-                    Fields::Unit => {
-                        self.generics.where_clause.to_tokens(tokens);
-                        TokensOrDefault(&data.semi_token).to_tokens(tokens);
-                    }
-                },
-                Data::Enum(ref data) => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    data.brace_token.surround(tokens, |tokens| {
-                        data.variants.to_tokens(tokens);
-                    });
-                }
-                Data::Union(ref data) => {
-                    self.generics.where_clause.to_tokens(tokens);
-                    data.fields.to_tokens(tokens);
-                }
-            }
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/error.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use std::error::Error;
-use buffer::Cursor;
-use std::fmt::{self, Display};
-
-/// The result of a `Synom` parser.
-///
-/// Refer to the [module documentation] for details about parsing in Syn.
-///
-/// [module documentation]: index.html
-///
-/// *This type is available if Syn is built with the `"parsing"` feature.*
-pub type PResult<'a, O> = Result<(O, Cursor<'a>), ParseError>;
-
-/// An error with a default error message.
-///
-/// NOTE: We should provide better error messages in the future.
-pub fn parse_error<O>() -> PResult<'static, O> {
-    Err(ParseError(None))
-}
-
-/// Error returned when a `Synom` parser cannot parse the input tokens.
-///
-/// Refer to the [module documentation] for details about parsing in Syn.
-///
-/// [module documentation]: index.html
-///
-/// *This type is available if Syn is built with the `"parsing"` feature.*
-#[derive(Debug)]
-pub struct ParseError(Option<String>);
-
-impl Error for ParseError {
-    fn description(&self) -> &str {
-        match self.0 {
-            Some(ref desc) => desc,
-            None => "failed to parse",
-        }
-    }
-}
-
-impl Display for ParseError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        Display::fmt(self.description(), f)
-    }
-}
-
-impl ParseError {
-    // For syn use only. Not public API.
-    #[doc(hidden)]
-    pub fn new<T: Into<String>>(msg: T) -> Self {
-        ParseError(Some(msg.into()))
-    }
-}
deleted file mode 100644
--- a/third_party/rust/syn-0.12.12/src/expr.rs
+++ /dev/null
@@ -1,3573 +0,0 @@
-// Copyright 2018 Syn Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use super::*;
-use punctuated::Punctuated;
-use proc_macro2::{Span, TokenStream};
-#[cfg(feature = "extra-traits")]
-use std::hash::{Hash, Hasher};
-#[cfg(feature = "extra-traits")]
-use tt::TokenStreamHelper;
-#[cfg(feature = "full")]
-use std::mem;
-
-ast_enum_of_structs! {
-    /// A Rust expression.
-    ///
-    /// *This type is available if Syn is built with the `"derive"` or `"full"`
-    /// feature.*
-    ///
-    /// # Syntax tree enums
-    ///
-    /// This type is a syntax tree enum. In Syn this and other syntax tree enums
-    /// are designed to be traversed using the following rebinding idiom.
-    ///
-    /// ```
-    /// # use syn::Expr;
-    /// #
-    /// # fn example(expr: Expr) {
-    /// # const IGNORE: &str = stringify! {
-    /// let expr: Expr = /* ... */;
-    /// # };
-    /// match expr {
-    ///     Expr::MethodCall(expr) => {
-    ///         /* ... */
-    ///     }
-    ///     Expr::Cast(expr) => {
-    ///         /* ... */
-    ///     }
-    ///     Expr::IfLet(expr) => {
-    ///         /* ... */
-    ///     }
-    ///     /* ... */
-    ///     # _ => {}
-    /// }
-    /// # }
-    /// ```
-    ///
-    /// We begin with a variable `expr` of type `Expr` that has no fields
-    /// (because it is an enum), and by matching on it and rebinding a variable
-    /// with the same name `expr` we effectively imbue our variable with all of
-    /// the data fields provided by the variant that it turned out to be. So for
-    /// example above if we ended up in the `MethodCall` case then we get to use
-    /// `expr.receiver`, `expr.args` etc; if we ended up in the `IfLet` case we
-    /// get to use `expr.pat`, `expr.then_branch`, `expr.else_branch`.
-    ///
-    /// The pattern is similar if the input expression is borrowed:
-    ///
-    /// ```
-    /// # use syn::Expr;
-    /// #
-    /// # fn example(expr: &Expr) {
-    /// match *expr {
-    ///     Expr::MethodCall(ref expr) => {
-    /// #   }
-    /// #   _ => {}
-    /// # }
-    /// # }
-    /// ```
-    ///
-    /// This approach avoids repeating the variant names twice on every line.
-    ///
-    /// ```
-    /// # use syn::{Expr, ExprMethodCall};
-    /// #
-    /// # fn example(expr: Expr) {
-    /// # match expr {
-    /// Expr::MethodCall(ExprMethodCall { method, args, .. }) => { // repetitive