Merge inbound to mozilla-central. a=merge
authorNoemi Erli <nerli@mozilla.com>
Fri, 07 Dec 2018 23:40:06 +0200
changeset 508866 ca0f00593e38cdab54c3a990059bbf1150e77365
parent 508841 45cd802be3dd3d3271dc19a96e8a8adb7a73757e (current diff)
parent 508865 98c147abf490646ae54b3e94c35b820211c8057d (diff)
child 508867 21f77dc6811d390c937f927e5ce9b0320ea8c091
child 508906 904080f44dbd2ae3cc92c794a817b281d6cb7237
push id1905
push userffxbld-merge
push dateMon, 21 Jan 2019 12:33:13 +0000
treeherdermozilla-release@c2fca1944d8c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersmerge
milestone65.0a1
first release with
nightly linux32
ca0f00593e38 / 65.0a1 / 20181207214033 / files
nightly linux64
ca0f00593e38 / 65.0a1 / 20181207214033 / files
nightly mac
ca0f00593e38 / 65.0a1 / 20181207214033 / files
nightly win32
ca0f00593e38 / 65.0a1 / 20181207214033 / files
nightly win64
ca0f00593e38 / 65.0a1 / 20181207214033 / files
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
releases
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Merge inbound to mozilla-central. a=merge
gfx/webrender_bindings/WebRenderAPI.cpp
third_party/rust/darling_core/src/ast.rs
third_party/rust/darling_core/src/codegen/fmi_impl.rs
third_party/rust/darling_core/src/from_meta_item.rs
third_party/rust/darling_core/src/macros.rs
third_party/rust/darling_core/src/options/from_meta_item.rs
third_party/rust/synstructure-0.8.1/.cargo-checksum.json
third_party/rust/synstructure-0.8.1/Cargo.toml
third_party/rust/synstructure-0.8.1/LICENSE
third_party/rust/synstructure-0.8.1/README.md
third_party/rust/synstructure-0.8.1/src/lib.rs
third_party/rust/synstructure-0.8.1/src/macros.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -176,17 +176,17 @@ dependencies = [
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "bench-collections-gtest"
 version = "0.1.0"
 dependencies = [
- "fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "binary-space-partition"
 version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
@@ -672,42 +672,43 @@ 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.4.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "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)",
+ "darling_core 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "darling_macro 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "darling_core"
-version = "0.4.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "ident_case 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "proc-macro2 0.3.5 (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)",
+ "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "darling_macro"
-version = "0.4.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
- "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)",
+ "darling_core 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.7 (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.43 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -890,17 +891,17 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
  "miniz_oxide_c_api 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "fnv"
-version = "1.0.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "foreign-types"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
@@ -1097,17 +1098,17 @@ dependencies = [
 
 [[package]]
 name = "h2"
 version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "bytes 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "futures 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)",
  "http 0.1.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "indexmap 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "tokio-io 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -1120,17 +1121,17 @@ dependencies = [
 ]
 
 [[package]]
 name = "http"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "bytes 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
- "fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "itoa 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "httparse"
 version = "1.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
@@ -1427,19 +1428,19 @@ dependencies = [
  "thin-slice 0.1.1 (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.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)",
+ "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synstructure 0.10.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]]
@@ -2403,20 +2404,21 @@ 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.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)",
+ "darling 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "quote 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.7 (registry+https://github.com/rust-lang/crates.io-index)",
+ "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "style_traits"
 version = "0.0.1"
 dependencies = [
  "app_units 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2476,27 +2478,16 @@ source = "registry+https://github.com/ru
 dependencies = [
  "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.3 (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.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "proc-macro2 0.3.5 (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 = "synstructure"
 version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "syn 0.15.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
@@ -3177,19 +3168,19 @@ dependencies = [
 "checksum cssparser 0.25.0 (registry+https://github.com/rust-lang/crates.io-index)" = "730363a45c4e248d4f21d3e5c1156d1a9cdec0855056c0d9539e814bc59865c3"
 "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.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.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 darling 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "7f000e7b03a0083a30e1f10b1428a530849c21e72b338fa76869b5dbc4b045bf"
+"checksum darling_core 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "86bc5ce438f4b703755d12f59bbf0a16c642766d4534e922db47569dbdd0b998"
+"checksum darling_macro 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9973050ba46be2a2935a7b316147f41a808ac604b8f0fef6eba77fd47a89daeb"
 "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 digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
 "checksum dirs 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "88972de891f6118092b643d85a0b28e0678e0f948d7f879aa32f2d5aafe97d2a"
 "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.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "7b46afd0d0bbbea88fc083ea293e40865e26a75ec9d38cf5d05a23ac3e2ffe02"
@@ -3200,17 +3191,17 @@ dependencies = [
 "checksum env_logger 0.5.6 (registry+https://github.com/rust-lang/crates.io-index)" = "0561146661ae44c579e993456bc76d11ce1e0c7d745e57b2fa7146b6e49fa2ad"
 "checksum error-chain 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ff511d5dc435d703f4971bc399647c9bc38e20cb41452e3b9feb4765419ed3f3"
 "checksum euclid 0.19.3 (registry+https://github.com/rust-lang/crates.io-index)" = "600657e7e5c03bfbccdc68721bc3b5abcb761553973387124eae9c9e4f02c210"
 "checksum failure 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6dd377bcc1b1b7ce911967e3ec24fa19c3224394ec05b54aa7b083d498341ac7"
 "checksum failure_derive 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "64c2d913fe8ed3b6c6518eedf4538255b989945c14c2a7d5cbff62a5e2120596"
 "checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
 "checksum fixedbitset 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "85cb8fec437468d86dc7c83ca7cfc933341d561873275f22dd5eedefa63a6478"
 "checksum flate2 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "9fac2277e84e5e858483756647a9d0aa8d9a2b7cba517fd84325a0aaa69a0909"
-"checksum fnv 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "6cc484842f1e2884faf56f529f960cc12ad8c71ce96cc7abba0a067c98fee344"
+"checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
 "checksum foreign-types 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)" = "5ebc04f19019fff1f2d627b5581574ead502f80c48c88900575a46e0840fe5d0"
 "checksum freetype 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b659e75b7a7338fe75afd7f909fc2b71937845cffb6ebe54ba2e50f13d8e903d"
 "checksum fs2 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
 "checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
 "checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
 "checksum futures 0.1.23 (registry+https://github.com/rust-lang/crates.io-index)" = "884dbe32a6ae4cd7da5c6db9b78114449df9953b8d490c9d7e1b51720b922c62"
 "checksum futures-cpupool 0.1.8 (registry+https://github.com/rust-lang/crates.io-index)" = "ab90cde24b3319636588d0c35fe03b1333857621051837ed769faefb4c2162e4"
 "checksum fxhash 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
@@ -3341,17 +3332,16 @@ dependencies = [
 "checksum string_cache_codegen 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)" = "1eea1eee654ef80933142157fdad9dd8bc43cf7c74e999e369263496f04ff4da"
 "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.13.1 (registry+https://github.com/rust-lang/crates.io-index)" = "91b52877572087400e83d24b9178488541e3d535259e04ff17a63df1e5ceff59"
 "checksum syn 0.14.6 (registry+https://github.com/rust-lang/crates.io-index)" = "4e4b5274d4a0a3d2749d5c158dc64d3403e60554dc61194648787ada5212473d"
 "checksum syn 0.15.7 (registry+https://github.com/rust-lang/crates.io-index)" = "455a6ec9b368f8c479b0ae5494d13b22dc00990d2f00d68c9dc6a2dc4f17f210"
 "checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
-"checksum synstructure 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "98cad891cd238c98e1f0aec9f7c0f620aa696e4e5f7daba56ac67b5e86a6b049"
 "checksum target-lexicon 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "4af5e2227f0b887d591d3724b796a96eff04226104d872f5b3883fcd427d64b9"
 "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 termion 1.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "689a3bdfaab439fd92bc87df5c4c78417d3cbe537487274e9b0b2dce76e92096"
 "checksum textwrap 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c0b59b6b4b44d867f1370ef1bd91bfb262bf07bf0ae65c202ea2fbc16153b693"
 "checksum thin-slice 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c"
--- a/dom/bindings/parser/WebIDL.py
+++ b/dom/bindings/parser/WebIDL.py
@@ -604,16 +604,44 @@ class IDLExternalInterface(IDLObjectWith
 
     def isNavigatorProperty(self):
         return False
 
     def _getDependentObjects(self):
         return set()
 
 
+class IDLPartialDictionary(IDLObject):
+    def __init__(self, location, name, members, nonPartialDictionary):
+        assert isinstance(name, IDLUnresolvedIdentifier)
+
+        IDLObject.__init__(self, location)
+        self.identifier = name
+        self.members = members
+        self._nonPartialDictionary = nonPartialDictionary
+        self._finished = False
+        nonPartialDictionary.addPartialDictionary(self)
+
+    def addExtendedAttributes(self, attrs):
+        pass
+
+    def finish(self, scope):
+        if self._finished:
+            return
+        self._finished = True
+
+        # Need to make sure our non-partial dictionary gets
+        # finished so it can report cases when we only have partial
+        # dictionaries.
+        self._nonPartialDictionary.finish(scope)
+
+    def validate(self):
+        pass
+
+
 class IDLPartialInterfaceOrNamespace(IDLObject):
     def __init__(self, location, name, members, nonPartialInterfaceOrNamespace):
         assert isinstance(name, IDLUnresolvedIdentifier)
 
         IDLObject.__init__(self, location)
         self.identifier = name
         self.members = members
         # propagatedExtendedAttrs are the ones that should get
@@ -1837,16 +1865,17 @@ class IDLDictionary(IDLObjectWithScope):
     def __init__(self, location, parentScope, name, parent, members):
         assert isinstance(parentScope, IDLScope)
         assert isinstance(name, IDLUnresolvedIdentifier)
         assert not parent or isinstance(parent, IDLIdentifierPlaceholder)
 
         self.parent = parent
         self._finished = False
         self.members = list(members)
+        self._partialDictionaries = []
 
         IDLObjectWithScope.__init__(self, location, parentScope, name)
 
     def __str__(self):
         return "Dictionary '%s'" % self.identifier.name
 
     def isDictionary(self):
         return True
@@ -1873,16 +1902,21 @@ class IDLDictionary(IDLObjectWithScope):
                 raise WebIDLError("Dictionary %s has parent that is not a dictionary" %
                                   self.identifier.name,
                                   [oldParent.location, self.parent.location])
 
             # Make sure the parent resolves all its members before we start
             # looking at them.
             self.parent.finish(scope)
 
+        # Now go ahead and merge in our partial dictionaries.
+        for partial in self._partialDictionaries:
+            partial.finish(scope)
+            self.members.extend(partial.members)
+
         for member in self.members:
             member.resolve(self)
             if not member.isComplete():
                 member.complete(scope)
                 assert member.type.isComplete()
 
         # Members of a dictionary are sorted in lexicographic order
         self.members.sort(cmp=cmp, key=lambda x: x.identifier.name)
@@ -1977,16 +2011,19 @@ class IDLDictionary(IDLObjectWithScope):
                               [attrs[0].location, self.location])
 
     def _getDependentObjects(self):
         deps = set(self.members)
         if (self.parent):
             deps.add(self.parent)
         return deps
 
+    def addPartialDictionary(self, partial):
+        assert self.identifier.name == partial.identifier.name
+        self._partialDictionaries.append(partial)
 
 class IDLEnum(IDLObjectWithIdentifier):
     def __init__(self, location, parentScope, name, values):
         assert isinstance(parentScope, IDLScope)
         assert isinstance(name, IDLUnresolvedIdentifier)
 
         if len(values) != len(set(values)):
             raise WebIDLError("Enum %s has multiple identical strings" % name.name,
@@ -5525,19 +5562,20 @@ class Parser(Tokenizer):
                                     | Interface
         """
         assert p[1]
         p[0] = p[1]
 
     def handleNonPartialObject(self, location, identifier, constructor,
                                constructorArgs, nonPartialArgs):
         """
-        This handles non-partial objects (interfaces and namespaces) by
-        checking for an existing partial object, and promoting it to
-        non-partial as needed.  The return value is the non-partial object.
+        This handles non-partial objects (interfaces, namespaces and
+        dictionaries) by checking for an existing partial object, and promoting
+        it to non-partial as needed.  The return value is the non-partial
+        object.
 
         constructorArgs are all the args for the constructor except the last
         one: isKnownNonPartial.
 
         nonPartialArgs are the args for the setNonPartial call.
         """
         # The name of the class starts with "IDL", so strip that off.
         # Also, starts with a capital letter after that, so nix that
@@ -5617,34 +5655,35 @@ class Parser(Tokenizer):
             Partial : PARTIAL PartialDefinition
         """
         p[0] = p[2]
 
     def p_PartialDefinition(self, p):
         """
             PartialDefinition : PartialInterface
                               | PartialNamespace
+                              | PartialDictionary
         """
         p[0] = p[1]
 
     def handlePartialObject(self, location, identifier, nonPartialConstructor,
                             nonPartialConstructorArgs,
                             partialConstructorArgs):
         """
-        This handles partial objects (interfaces and namespaces) by checking for
-        an existing non-partial object, and adding ourselves to it as needed.
-        The return value is our partial object.  For now we just use
-        IDLPartialInterfaceOrNamespace for partial objects.
+        This handles partial objects (interfaces, namespaces and dictionaries)
+        by checking for an existing non-partial object, and adding ourselves to
+        it as needed.  The return value is our partial object.  We use
+        IDLPartialInterfaceOrNamespace for partial interfaces or namespaces,
+        and IDLPartialDictionary for partial dictionaries.
 
         nonPartialConstructorArgs are all the args for the non-partial
         constructor except the last two: members and isKnownNonPartial.
 
-        partialConstructorArgs are the arguments for the
-        IDLPartialInterfaceOrNamespace constructor, except the last one (the
-        non-partial object).
+        partialConstructorArgs are the arguments for the partial object
+        constructor, except the last one (the non-partial object).
         """
         # The name of the class starts with "IDL", so strip that off.
         # Also, starts with a capital letter after that, so nix that
         # as well.
         prettyname = nonPartialConstructor.__name__[3:].lower()
 
         nonPartialObject = None
         try:
@@ -5659,19 +5698,29 @@ class Parser(Tokenizer):
             if isinstance(ex, WebIDLError):
                 raise ex
             pass
 
         if not nonPartialObject:
             nonPartialObject = nonPartialConstructor(
                 # No members, False for isKnownNonPartial
                 *(nonPartialConstructorArgs + [[], False]))
-        partialInterface = IDLPartialInterfaceOrNamespace(
-            *(partialConstructorArgs + [nonPartialObject]))
-        return partialInterface
+
+        partialObject = None
+        if isinstance(nonPartialObject, IDLDictionary):
+            partialObject = IDLPartialDictionary(
+                *(partialConstructorArgs + [nonPartialObject]))
+        elif isinstance(nonPartialObject, (IDLInterface, IDLNamespace)):
+            partialObject = IDLPartialInterfaceOrNamespace(
+                *(partialConstructorArgs + [nonPartialObject]))
+        else:
+            raise WebIDLError("Unknown partial object type %s" %
+                    type(partialObject))
+
+        return partialObject
 
     def p_PartialInterface(self, p):
         """
             PartialInterface : INTERFACE IDENTIFIER LBRACE InterfaceMembers RBRACE SEMICOLON
         """
         location = self.getLocation(p, 1)
         identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
         members = p[4]
@@ -5689,16 +5738,29 @@ class Parser(Tokenizer):
         identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
         members = p[4]
 
         p[0] = self.handlePartialObject(
             location, identifier, IDLNamespace,
             [location, self.globalScope(), identifier],
             [location, identifier, members])
 
+    def p_PartialDictionary(self, p):
+        """
+            PartialDictionary : DICTIONARY IDENTIFIER LBRACE DictionaryMembers RBRACE SEMICOLON
+        """
+        location = self.getLocation(p, 1)
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+        members = p[4]
+
+        p[0] = self.handlePartialObject(
+            location, identifier, IDLDictionary,
+            [location, self.globalScope(), identifier],
+            [location, identifier, members])
+
     def p_Inheritance(self, p):
         """
             Inheritance : COLON ScopedName
         """
         p[0] = IDLIdentifierPlaceholder(self.getLocation(p, 2), p[2])
 
     def p_InheritanceEmpty(self, p):
         """
--- a/dom/bindings/parser/tests/test_dictionary.py
+++ b/dom/bindings/parser/tests/test_dictionary.py
@@ -21,32 +21,75 @@ def WebIDLTest(parser, harness):
                   "'o' comes before 'p'")
     harness.check(dict1.members[1].identifier.name, "parent",
                   "'o' really comes before 'p'")
     harness.check(dict2.members[0].identifier.name, "aaandAnother",
                   "'a' comes before 'c'")
     harness.check(dict2.members[1].identifier.name, "child",
                   "'a' really comes before 'c'")
 
+    # Test partial dictionary.
+    parser = parser.reset();
+    parser.parse("""
+      dictionary A {
+        long c;
+        long g;
+      };
+      partial dictionary A {
+        long h;
+        long d;
+      };
+    """)
+    results = parser.finish()
+
+    dict1 = results[0];
+    harness.check(len(dict1.members), 4, "Dict1 has four members")
+    harness.check(dict1.members[0].identifier.name, "c",
+                  "c should be first")
+    harness.check(dict1.members[1].identifier.name, "d",
+                  "d should come after c")
+    harness.check(dict1.members[2].identifier.name, "g",
+                  "g should come after d")
+    harness.check(dict1.members[3].identifier.name, "h",
+                  "h should be last")
+
     # Now reset our parser
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
           dictionary Dict {
             long prop = 5;
             long prop;
           };
         """)
         results = parser.finish()
     except:
         threw = True
 
     harness.ok(threw, "Should not allow name duplication in a dictionary")
 
+    # Test no name duplication across normal and partial dictionary.
+    parser = parser.reset();
+    threw = False
+    try:
+        parser.parse("""
+          dictionary A {
+            long prop = 5;
+          };
+          partial dictionary A {
+            long prop;
+          };
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow name duplication across normal and partial dictionary")
+
     # Now reset our parser again
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
           dictionary Dict1 : Dict2 {
             long prop = 5;
           };
--- a/gfx/thebes/gfxPrefs.h
+++ b/gfx/thebes/gfxPrefs.h
@@ -543,16 +543,17 @@ class gfxPrefs final {
   DECL_GFX_PREF(Live, "gfx.webrender.blob-images",             WebRenderBlobImages, bool, true);
   DECL_GFX_PREF(Live, "gfx.webrender.blob.invalidation",       WebRenderBlobInvalidation, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.blob.paint-flashing",     WebRenderBlobPaintFlashing, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.dl.dump-parent",          WebRenderDLDumpParent, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.dl.dump-content",         WebRenderDLDumpContent, bool, false);
   DECL_GFX_PREF(Once, "gfx.webrender.enabled",                 WebRenderEnabledDoNotUseDirectly, bool, false);
   DECL_GFX_PREF(Once, "gfx.webrender.force-disabled",          WebRenderForceDisabled, bool, false);
   DECL_GFX_PREF(Live, "gfx.webrender.highlight-painted-layers",WebRenderHighlightPaintedLayers, bool, false);
+  DECL_GFX_PREF(Live, "gfx.webrender.picture-caching",         WebRenderPictureCaching, bool, false);
 
   // Use vsync events generated by hardware
   DECL_GFX_PREF(Once, "gfx.work-around-driver-bugs",           WorkAroundDriverBugs, bool, true);
 
   DECL_GFX_PREF(Live, "gl.ignore-dx-interop2-blacklist",       IgnoreDXInterop2Blacklist, bool, false);
   DECL_GFX_PREF(Live, "gl.msaa-level",                         MSAALevel, uint32_t, 2);
 #if defined(XP_MACOSX)
   DECL_GFX_PREF(Live, "gl.multithreaded",                      GLMultithreaded, bool, false);
--- a/gfx/webrender_bindings/WebRenderAPI.cpp
+++ b/gfx/webrender_bindings/WebRenderAPI.cpp
@@ -68,17 +68,18 @@ class NewRenderer : public RendererEvent
     *mUseANGLE = compositor->UseANGLE();
     *mUseDComp = compositor->UseDComp();
     *mUseTripleBuffering = compositor->UseTripleBuffering();
 
     bool supportLowPriorityTransactions = true;  // TODO only for main windows.
     wr::Renderer* wrRenderer = nullptr;
     if (!wr_window_new(
             aWindowId, mSize.width, mSize.height,
-            supportLowPriorityTransactions, compositor->gl(),
+            supportLowPriorityTransactions, gfxPrefs::WebRenderPictureCaching(),
+            compositor->gl(),
             aRenderThread.ProgramCache() ? aRenderThread.ProgramCache()->Raw()
                                          : nullptr,
             aRenderThread.Shaders() ? aRenderThread.Shaders()->RawShaders()
                                     : nullptr,
             aRenderThread.ThreadPool().Raw(), &WebRenderMallocSizeOf,
             mDocHandle, &wrRenderer, mMaxTextureSize)) {
       // wr_window_new puts a message into gfxCriticalNote if it returns false
       return;
--- a/gfx/webrender_bindings/src/bindings.rs
+++ b/gfx/webrender_bindings/src/bindings.rs
@@ -985,16 +985,17 @@ fn wr_device_new(gl_context: *mut c_void
 }
 
 // Call MakeCurrent before this.
 #[no_mangle]
 pub extern "C" fn wr_window_new(window_id: WrWindowId,
                                 window_width: i32,
                                 window_height: i32,
                                 support_low_priority_transactions: bool,
+                                enable_picture_caching: bool,
                                 gl_context: *mut c_void,
                                 program_cache: Option<&mut WrProgramCache>,
                                 shaders: Option<&mut WrShaders>,
                                 thread_pool: *mut WrThreadPool,
                                 size_of_op: VoidPtrToSizeFn,
                                 out_handle: &mut *mut DocumentHandle,
                                 out_renderer: &mut *mut Renderer,
                                 out_max_texture_size: *mut i32)
@@ -1065,16 +1066,17 @@ pub extern "C" fn wr_window_new(window_i
         renderer_id: Some(window_id.0),
         upload_method,
         scene_builder_hooks: Some(Box::new(APZCallbacks::new(window_id))),
         sampler: Some(Box::new(SamplerCallback::new(window_id))),
         max_texture_size: Some(8192), // Moz2D doesn't like textures bigger than this
         clear_color: Some(ColorF::new(0.0, 0.0, 0.0, 0.0)),
         precache_flags,
         namespace_alloc_by_client: true,
+        enable_picture_caching,
         ..Default::default()
     };
 
     let notifier = Box::new(CppNotifier {
         window_id: window_id,
     });
     let (renderer, sender) = match Renderer::new(gl, notifier, opts, shaders) {
         Ok((renderer, sender)) => (renderer, sender),
--- a/gfx/webrender_bindings/webrender_ffi_generated.h
+++ b/gfx/webrender_bindings/webrender_ffi_generated.h
@@ -1978,16 +1978,17 @@ void wr_vec_u8_push_bytes(WrVecU8 *aV,
                           ByteSlice aBytes)
 WR_FUNC;
 
 WR_INLINE
 bool wr_window_new(WrWindowId aWindowId,
                    int32_t aWindowWidth,
                    int32_t aWindowHeight,
                    bool aSupportLowPriorityTransactions,
+                   bool aEnablePictureCaching,
                    void *aGlContext,
                    WrProgramCache *aProgramCache,
                    WrShaders *aShaders,
                    WrThreadPool *aThreadPool,
                    VoidPtrToSizeFn aSizeOfOp,
                    DocumentHandle **aOutHandle,
                    Renderer **aOutRenderer,
                    int32_t *aOutMaxTextureSize)
--- a/modules/libpref/init/all.js
+++ b/modules/libpref/init/all.js
@@ -945,16 +945,17 @@ pref("gfx.webrender.debug.epochs", false
 pref("gfx.webrender.debug.compact-profiler", false);
 pref("gfx.webrender.debug.echo-driver-messages", false);
 pref("gfx.webrender.debug.new-frame-indicator", false);
 pref("gfx.webrender.debug.new-scene-indicator", false);
 pref("gfx.webrender.debug.show-overdraw", false);
 pref("gfx.webrender.debug.slow-frame-indicator", false);
 pref("gfx.webrender.dl.dump-parent", false);
 pref("gfx.webrender.dl.dump-content", false);
+pref("gfx.webrender.picture-caching", false);
 
 pref("accessibility.browsewithcaret", false);
 pref("accessibility.warn_on_browsewithcaret", true);
 
 pref("accessibility.browsewithcaret_shortcut.enabled", true);
 
 #ifndef XP_MACOSX
 // Tab focus model bit field:
--- 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.5.1"
-syn = { version = "0.13.1", features = ["full"] }
-synstructure = "0.8"
+proc-macro2 = "0.4"
+syn = { version = "0.15", features = ["full"] }
+synstructure = "0.10"
--- a/servo/components/malloc_size_of_derive/lib.rs
+++ b/servo/components/malloc_size_of_derive/lib.rs
@@ -5,26 +5,26 @@
 // 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.
 
-extern crate quote;
+extern crate proc_macro2;
 #[macro_use]
 extern crate syn;
 #[macro_use]
 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 {
+fn malloc_size_of_derive(s: synstructure::Structure) -> proc_macro2::TokenStream {
     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" =>
@@ -56,17 +56,17 @@ fn malloc_size_of_derive(s: synstructure
         }
     });
 
     let ast = s.ast();
     let name = &ast.ident;
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
     let mut where_clause = where_clause.unwrap_or(&parse_quote!(where)).clone();
     for param in ast.generics.type_params() {
-        let ident = param.ident;
+        let ident = &param.ident;
         where_clause
             .predicates
             .push(parse_quote!(#ident: ::malloc_size_of::MallocSizeOf));
     }
 
     let tokens = quote! {
         impl #impl_generics ::malloc_size_of::MallocSizeOf for #name #ty_generics #where_clause {
             #[inline]
--- a/servo/components/style_derive/Cargo.toml
+++ b/servo/components/style_derive/Cargo.toml
@@ -5,12 +5,13 @@ authors = ["The Servo Project Developers
 license = "MPL-2.0"
 publish = false
 
 [lib]
 path = "lib.rs"
 proc-macro = true
 
 [dependencies]
-darling = "0.4"
-quote = "0.5.1"
-syn = { version = "0.13.1", features = ["visit"] }
-synstructure = "0.8"
+darling = "0.8"
+proc-macro2 = "0.4"
+quote = "0.6"
+syn = { version = "0.15", features = ["visit"] }
+synstructure = "0.10"
--- a/servo/components/style_derive/animate.rs
+++ b/servo/components/style_derive/animate.rs
@@ -1,19 +1,20 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
 use darling::util::IdentList;
-use quote::Tokens;
+use proc_macro2::TokenStream;
+use quote::TokenStreamExt;
 use syn::{DeriveInput, Path};
 use synstructure::{Structure, VariantInfo};
 
-pub fn derive(mut input: DeriveInput) -> Tokens {
+pub fn derive(mut input: DeriveInput) -> TokenStream {
     let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
     let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
         if !no_bound.contains(&param.ident) {
             cg::add_predicate(
                 &mut where_clause,
                 parse_quote!(#param: crate::values::animated::Animate),
@@ -62,17 +63,17 @@ pub fn derive(mut input: DeriveInput) ->
                 match (self, other) {
                     #match_body
                 }
             }
         }
     }
 }
 
-fn derive_variant_arm(variant: &VariantInfo) -> Result<Tokens, ()> {
+fn derive_variant_arm(variant: &VariantInfo) -> Result<TokenStream, ()> {
     let variant_attrs = cg::parse_variant_attrs_from_ast::<AnimationVariantAttrs>(&variant.ast());
     if variant_attrs.error {
         return Err(());
     }
     let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
     let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");
     let (result_value, result_info) = cg::value(&variant, "result");
     let mut computations = quote!();
--- a/servo/components/style_derive/cg.rs
+++ b/servo/components/style_derive/cg.rs
@@ -1,31 +1,32 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use darling::{FromDeriveInput, FromField, FromVariant};
-use quote::Tokens;
+use proc_macro2::{Span, TokenStream};
+use quote::TokenStreamExt;
 use syn::{self, AngleBracketedGenericArguments, Binding, DeriveInput, Field};
 use syn::{GenericArgument, GenericParam, Ident, Path};
 use syn::{PathArguments, PathSegment, QSelf, Type, TypeArray};
 use syn::{TypeParam, TypeParen, TypePath, TypeSlice, TypeTuple};
 use syn::{Variant, WherePredicate};
 use synstructure::{self, BindStyle, BindingInfo, VariantAst, VariantInfo};
 
 pub fn add_predicate(where_clause: &mut Option<syn::WhereClause>, pred: WherePredicate) {
     where_clause
         .get_or_insert(parse_quote!(where))
         .predicates
         .push(pred);
 }
 
-pub fn fmap_match<F>(input: &DeriveInput, bind_style: BindStyle, mut f: F) -> Tokens
+pub fn fmap_match<F>(input: &DeriveInput, bind_style: BindStyle, mut f: F) -> TokenStream
 where
-    F: FnMut(BindingInfo) -> Tokens,
+    F: FnMut(BindingInfo) -> TokenStream,
 {
     let mut s = synstructure::Structure::new(input);
     s.variants_mut().iter_mut().for_each(|v| {
         v.bind_with(|_| bind_style);
     });
     s.each_variant(|variant| {
         let (mapped, mapped_fields) = value(variant, "mapped");
         let fields_pairs = variant.bindings().into_iter().zip(mapped_fields);
@@ -47,17 +48,17 @@ pub fn fmap_trait_output(input: &DeriveI
                 .generics
                 .params
                 .iter()
                 .map(|arg| match arg {
                     &GenericParam::Lifetime(ref data) => {
                         GenericArgument::Lifetime(data.lifetime.clone())
                     },
                     &GenericParam::Type(ref data) => {
-                        let ident = data.ident;
+                        let ident = &data.ident;
                         GenericArgument::Type(parse_quote!(<#ident as #trait_path>::#trait_output))
                     },
                     ref arg => panic!("arguments {:?} cannot be mapped yet", arg),
                 })
                 .collect(),
             colon2_token: Default::default(),
             gt_token: Default::default(),
             lt_token: Default::default(),
@@ -91,17 +92,17 @@ where
                 .collect(),
             ..inner.clone()
         }),
         Type::Path(TypePath {
             qself: None,
             ref path,
         }) => {
             if let Some(ident) = path_to_ident(path) {
-                if params.iter().any(|param| param.ident == ident) {
+                if params.iter().any(|ref param| &param.ident == ident) {
                     return f(ident);
                 }
             }
             Type::from(TypePath {
                 qself: None,
                 path: map_type_params_in_path(path, params, f),
             })
         },
@@ -204,17 +205,17 @@ where
     }
 }
 
 pub fn parse_variant_attrs_from_ast<A>(variant: &VariantAst) -> A
 where
     A: FromVariant,
 {
     let v = Variant {
-        ident: *variant.ident,
+        ident: variant.ident.clone(),
         attrs: variant.attrs.to_vec(),
         fields: variant.fields.clone(),
         discriminant: variant.discriminant.clone(),
     };
     parse_variant_attrs(&v)
 }
 
 pub fn parse_variant_attrs<A>(variant: &Variant) -> A
@@ -222,30 +223,33 @@ where
     A: FromVariant,
 {
     match A::from_variant(variant) {
         Ok(attrs) => attrs,
         Err(e) => panic!("failed to parse variant attributes: {}", e),
     }
 }
 
-pub fn ref_pattern<'a>(variant: &'a VariantInfo, prefix: &str) -> (Tokens, Vec<BindingInfo<'a>>) {
+pub fn ref_pattern<'a>(
+    variant: &'a VariantInfo,
+    prefix: &str,
+) -> (TokenStream, Vec<BindingInfo<'a>>) {
     let mut v = variant.clone();
     v.bind_with(|_| BindStyle::Ref);
-    v.bindings_mut()
-        .iter_mut()
-        .for_each(|b| b.binding = Ident::from(format!("{}_{}", b.binding, prefix)));
+    v.bindings_mut().iter_mut().for_each(|b| {
+        b.binding = Ident::new(&format!("{}_{}", b.binding, prefix), Span::call_site())
+    });
     (v.pat(), v.bindings().iter().cloned().collect())
 }
 
-pub fn value<'a>(variant: &'a VariantInfo, prefix: &str) -> (Tokens, Vec<BindingInfo<'a>>) {
+pub fn value<'a>(variant: &'a VariantInfo, prefix: &str) -> (TokenStream, Vec<BindingInfo<'a>>) {
     let mut v = variant.clone();
-    v.bindings_mut()
-        .iter_mut()
-        .for_each(|b| b.binding = Ident::from(format!("{}_{}", b.binding, prefix)));
+    v.bindings_mut().iter_mut().for_each(|b| {
+        b.binding = Ident::new(&format!("{}_{}", b.binding, prefix), Span::call_site())
+    });
     v.bind_with(|_| BindStyle::Move);
     (v.pat(), v.bindings().iter().cloned().collect())
 }
 
 /// Transforms "FooBar" to "foo-bar".
 ///
 /// If the first Camel segment is "Moz", "Webkit", or "Servo", the result string
 /// is prepended with "-".
--- a/servo/components/style_derive/compute_squared_distance.rs
+++ b/servo/components/style_derive/compute_squared_distance.rs
@@ -1,19 +1,20 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::animate::{AnimationFieldAttrs, AnimationInputAttrs, AnimationVariantAttrs};
 use crate::cg;
-use quote::Tokens;
+use proc_macro2::TokenStream;
+use quote::TokenStreamExt;
 use syn::{DeriveInput, Path};
 use synstructure;
 
-pub fn derive(mut input: DeriveInput) -> Tokens {
+pub fn derive(mut input: DeriveInput) -> TokenStream {
     let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
     let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
         if !no_bound.contains(&param.ident) {
             cg::add_predicate(
                 &mut where_clause,
                 parse_quote!(#param: crate::values::distance::ComputeSquaredDistance),
--- a/servo/components/style_derive/lib.rs
+++ b/servo/components/style_derive/lib.rs
@@ -2,16 +2,17 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 #![recursion_limit = "128"]
 
 #[macro_use]
 extern crate darling;
 extern crate proc_macro;
+extern crate proc_macro2;
 #[macro_use]
 extern crate quote;
 #[macro_use]
 extern crate syn;
 extern crate synstructure;
 
 use proc_macro::TokenStream;
 
--- a/servo/components/style_derive/parse.rs
+++ b/servo/components/style_derive/parse.rs
@@ -1,26 +1,26 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
 use crate::to_css::CssVariantAttrs;
-use quote::Tokens;
+use proc_macro2::TokenStream;
 use syn::{DeriveInput, Path};
 use synstructure;
 
 #[darling(attributes(parse), default)]
 #[derive(Default, FromVariant)]
 pub struct ParseVariantAttrs {
     pub aliases: Option<String>,
     pub condition: Option<Path>,
 }
 
-pub fn derive(input: DeriveInput) -> Tokens {
+pub fn derive(input: DeriveInput) -> TokenStream {
     let name = &input.ident;
     let s = synstructure::Structure::new(&input);
 
     let mut saw_condition = false;
     let match_body = s.variants().iter().fold(quote!(), |match_body, variant| {
         let bindings = variant.bindings();
         assert!(
             bindings.is_empty(),
@@ -31,17 +31,17 @@ pub fn derive(input: DeriveInput) -> Tok
         let parse_attrs = cg::parse_variant_attrs_from_ast::<ParseVariantAttrs>(&variant.ast());
         if css_variant_attrs.skip {
             return match_body;
         }
 
         let identifier = cg::to_css_identifier(
             &css_variant_attrs
                 .keyword
-                .unwrap_or(variant.ast().ident.as_ref().into()),
+                .unwrap_or(variant.ast().ident.to_string()),
         );
         let ident = &variant.ast().ident;
 
         saw_condition |= parse_attrs.condition.is_some();
         let condition = match parse_attrs.condition {
             Some(ref p) => quote! { if #p(context) },
             None => quote!{},
         };
--- a/servo/components/style_derive/specified_value_info.rs
+++ b/servo/components/style_derive/specified_value_info.rs
@@ -1,25 +1,26 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
 use crate::parse::ParseVariantAttrs;
 use crate::to_css::{CssFieldAttrs, CssInputAttrs, CssVariantAttrs};
-use quote::Tokens;
+use proc_macro2::TokenStream;
+use quote::TokenStreamExt;
 use syn::{Data, DeriveInput, Fields, Ident, Type};
 
-pub fn derive(mut input: DeriveInput) -> Tokens {
+pub fn derive(mut input: DeriveInput) -> TokenStream {
     let css_attrs = cg::parse_input_attrs::<CssInputAttrs>(&input);
     let mut types = vec![];
     let mut values = vec![];
 
-    let input_ident = input.ident;
-    let input_name = || cg::to_css_identifier(input_ident.as_ref());
+    let input_ident = &input.ident;
+    let input_name = || cg::to_css_identifier(&input_ident.to_string());
     if let Some(function) = css_attrs.function {
         values.push(function.explicit().unwrap_or_else(input_name));
     // If the whole value is wrapped in a function, value types of
     // its fields should not be propagated.
     } else {
         let mut where_clause = input.generics.where_clause.take();
         for param in input.generics.type_params() {
             cg::add_predicate(
@@ -44,17 +45,17 @@ pub fn derive(mut input: DeriveInput) ->
                         }
                     }
                     if let Some(other_values) = info_attrs.other_values {
                         for value in other_values.split(",") {
                             values.push(value.to_string());
                         }
                     }
                     let ident = &v.ident;
-                    let variant_name = || cg::to_css_identifier(ident.as_ref());
+                    let variant_name = || cg::to_css_identifier(&ident.to_string());
                     if info_attrs.starts_with_keyword {
                         values.push(variant_name());
                         continue;
                     }
                     if let Some(keyword) = css_attrs.keyword {
                         values.push(keyword);
                         continue;
                     }
@@ -147,17 +148,17 @@ fn derive_struct_fields<'a>(
             }
         }
         let css_attrs = cg::parse_field_attrs::<CssFieldAttrs>(field);
         if css_attrs.represents_keyword {
             let ident = field
                 .ident
                 .as_ref()
                 .expect("only named field should use represents_keyword");
-            values.push(cg::to_css_identifier(ident.as_ref()));
+            values.push(cg::to_css_identifier(&ident.to_string()));
             return None;
         }
         if let Some(if_empty) = css_attrs.if_empty {
             values.push(if_empty);
         }
         if !css_attrs.skip {
             Some(&field.ty)
         } else {
--- a/servo/components/style_derive/to_animated_value.rs
+++ b/servo/components/style_derive/to_animated_value.rs
@@ -1,18 +1,18 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
-use quote;
-use syn::DeriveInput;
+use proc_macro2::{Span, TokenStream};
+use syn::{DeriveInput, Ident};
 use synstructure::BindStyle;
 
-pub fn derive(mut input: DeriveInput) -> quote::Tokens {
+pub fn derive(mut input: DeriveInput) -> TokenStream {
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
         cg::add_predicate(
             &mut where_clause,
             parse_quote!(#param: crate::values::animated::ToAnimatedValue),
         );
     }
 
@@ -28,17 +28,17 @@ pub fn derive(mut input: DeriveInput) ->
     );
 
     input.generics.where_clause = where_clause;
     let name = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
     let animated_value_type = cg::fmap_trait_output(
         &input,
         &parse_quote!(crate::values::animated::ToAnimatedValue),
-        "AnimatedValue".into(),
+        Ident::new("AnimatedValue", Span::call_site()),
     );
 
     quote! {
         impl #impl_generics crate::values::animated::ToAnimatedValue for #name #ty_generics #where_clause {
             type AnimatedValue = #animated_value_type;
 
             #[allow(unused_variables)]
             #[inline]
--- a/servo/components/style_derive/to_animated_zero.rs
+++ b/servo/components/style_derive/to_animated_zero.rs
@@ -1,19 +1,20 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::animate::{AnimationFieldAttrs, AnimationInputAttrs, AnimationVariantAttrs};
 use crate::cg;
-use quote;
+use proc_macro2::TokenStream;
+use quote::TokenStreamExt;
 use syn;
 use synstructure;
 
-pub fn derive(mut input: syn::DeriveInput) -> quote::Tokens {
+pub fn derive(mut input: syn::DeriveInput) -> TokenStream {
     let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
     let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
         if !no_bound.contains(&param.ident) {
             cg::add_predicate(
                 &mut where_clause,
                 parse_quote!(#param: crate::values::animated::ToAnimatedZero),
--- a/servo/components/style_derive/to_computed_value.rs
+++ b/servo/components/style_derive/to_computed_value.rs
@@ -1,18 +1,18 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
-use quote::Tokens;
-use syn::DeriveInput;
+use proc_macro2::{Span, TokenStream};
+use syn::{DeriveInput, Ident};
 use synstructure::BindStyle;
 
-pub fn derive(mut input: DeriveInput) -> Tokens {
+pub fn derive(mut input: DeriveInput) -> TokenStream {
     let mut where_clause = input.generics.where_clause.take();
     let (to_body, from_body) = {
         let params = input.generics.type_params().collect::<Vec<_>>();
         for param in &params {
             cg::add_predicate(
                 &mut where_clause,
                 parse_quote!(#param: crate::values::computed::ToComputedValue),
             );
@@ -74,17 +74,17 @@ pub fn derive(mut input: DeriveInput) ->
                 }
             }
         };
     }
 
     let computed_value_type = cg::fmap_trait_output(
         &input,
         &parse_quote!(crate::values::computed::ToComputedValue),
-        "ComputedValue".into(),
+        Ident::new("ComputedValue", Span::call_site()),
     );
 
     quote! {
         impl #impl_generics crate::values::computed::ToComputedValue for #name #ty_generics #where_clause {
             type ComputedValue = #computed_value_type;
 
             #[allow(unused_variables)]
             #[inline]
--- a/servo/components/style_derive/to_css.rs
+++ b/servo/components/style_derive/to_css.rs
@@ -1,19 +1,20 @@
 /* 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 https://mozilla.org/MPL/2.0/. */
 
 use crate::cg;
 use darling::util::Override;
-use quote::{ToTokens, Tokens};
+use proc_macro2::TokenStream;
+use quote::{ToTokens, TokenStreamExt};
 use syn::{self, Data, Path, WhereClause};
 use synstructure::{BindingInfo, Structure, VariantInfo};
 
-pub fn derive(mut input: syn::DeriveInput) -> Tokens {
+pub fn derive(mut input: syn::DeriveInput) -> TokenStream {
     let mut where_clause = input.generics.where_clause.take();
     for param in input.generics.type_params() {
         cg::add_predicate(&mut where_clause, parse_quote!(#param: style_traits::ToCss));
     }
 
     let input_attrs = cg::parse_input_attrs::<CssInputAttrs>(&input);
     if let Data::Enum(_) = input.data {
         assert!(
@@ -61,19 +62,19 @@ pub fn derive(mut input: syn::DeriveInpu
                 }
             }
         });
     }
 
     impls
 }
 
-fn derive_variant_arm(variant: &VariantInfo, generics: &mut Option<WhereClause>) -> Tokens {
+fn derive_variant_arm(variant: &VariantInfo, generics: &mut Option<WhereClause>) -> TokenStream {
     let bindings = variant.bindings();
-    let identifier = cg::to_css_identifier(variant.ast().ident.as_ref());
+    let identifier = cg::to_css_identifier(&variant.ast().ident.to_string());
     let ast = variant.ast();
     let variant_attrs = cg::parse_variant_attrs_from_ast::<CssVariantAttrs>(&ast);
     let separator = if variant_attrs.comma { ", " } else { " " };
 
     if variant_attrs.skip {
         return quote!(Ok(()));
     }
     if variant_attrs.dimension {
@@ -113,17 +114,17 @@ fn derive_variant_arm(variant: &VariantI
     }
     expr
 }
 
 fn derive_variant_fields_expr(
     bindings: &[BindingInfo],
     where_clause: &mut Option<WhereClause>,
     separator: &str,
-) -> Tokens {
+) -> TokenStream {
     let mut iter = bindings
         .iter()
         .filter_map(|binding| {
             let attrs = cg::parse_field_attrs::<CssFieldAttrs>(&binding.ast());
             if attrs.skip {
                 return None;
             }
             Some((binding, attrs))
@@ -161,17 +162,17 @@ fn derive_variant_fields_expr(
         Ok(())
     }}
 }
 
 fn derive_single_field_expr(
     field: &BindingInfo,
     attrs: CssFieldAttrs,
     where_clause: &mut Option<WhereClause>,
-) -> Tokens {
+) -> TokenStream {
     let mut expr = if attrs.iterable {
         if let Some(if_empty) = attrs.if_empty {
             return quote! {
                 {
                     let mut iter = #field.iter().peekable();
                     if iter.peek().is_none() {
                         writer.raw_item(#if_empty)?;
                     } else {
@@ -188,17 +189,17 @@ fn derive_single_field_expr(
             }
         }
     } else if attrs.represents_keyword {
         let ident = field
             .ast()
             .ident
             .as_ref()
             .expect("Unnamed field with represents_keyword?");
-        let ident = cg::to_css_identifier(ident.as_ref());
+        let ident = cg::to_css_identifier(&ident.to_string());
         quote! {
             if *#field {
                 writer.raw_item(#ident)?;
             }
         }
     } else {
         if attrs.field_bound {
             let ty = &field.ast().ty;
--- a/taskcluster/taskgraph/manifests/fennec_nightly.yml
+++ b/taskcluster/taskgraph/manifests/fennec_nightly.yml
@@ -32,17 +32,17 @@ platform_names:
 default: &default
   from:
     - build
   all_locales: false
   description: "TODO"
   locale_prefix:
     by-locale:
       default: ''
-      en-US: '${locale}'
+      en-US: '${locale}/'
   source_path_modifier:  # Anything between artifact prefix and filename
     by-locale:
       default: '${locale}'
       multi: ''
   destinations:  # locale_prefix is appended
     by-locale:
       multi:
         - latest-${branch}-${path_platform}
--- a/third_party/rust/darling/.cargo-checksum.json
+++ b/third_party/rust/darling/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"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
+{"files":{"CHANGELOG.md":"06091817afa317ff86efb9aee3fa8d165358150a92c6369e4ab2958765c14af8","Cargo.toml":"82b023db972c6554f198cc926eaca456f945d6ac2cdc4df65cdeb5b186a1ced0","LICENSE":"8ea93490d74a5a1b1af3ff71d786271b3f1e5f0bea79ac16e02ec533cef040d6","README.md":"f70d772dd28cd14fc817c71d343b07ec8bfbe02dfe8d3e999a0185c6ef8731ec","examples/automatic_bounds.rs":"2716da31a5beed954da77866779ef77600686688a8890fefa7e23db628358104","examples/consume_fields.rs":"abcdd6a919a95a5c295e8d362db0367ab171fe3c8a80b23d83701765cd902d2d","examples/fallible_read.rs":"e06d5c045d3a47c0e00d3c77ed3aa1a1d5173d2c3f462dc1967379db3094af4c","examples/supports_struct.rs":"f2d84a4377e555ed7535e563c9593bd6a398a63b42f7da72381eea2fccec229f","publish.sh":"42795a155247c69402f8c4c917c9874a06dfde5a7606c8b59fc4e9ccd34233dd","src/lib.rs":"07da20edb52c4aba30f2b680b28ca96cf995859566b0db3b1d2e0ee967249a18","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","tests/accrue_errors.rs":"f873acf2a13dba88f508c3eb118d14e36515bf94b7ee914ddec2ae1eb55e381f","tests/computed_bound.rs":"2313da96a250b5948ca06bf86cb7158b55a59eba75334aa8ba27a46b28ede6b5","tests/custom_bound.rs":"4dd3e8fd76734d8f262e857773f53a820229ad6e10fe6fbbbe1f636c7da9eab0","tests/defaults.rs":"b544be90d18be26305a757e8468bf8735356889b59c167294d118e32ee7f82ea","tests/enums_newtype.rs":"723c761eab356f577e804a5e07f5efa244f70fb7525d20fceb1bc3852c8d742e","tests/enums_struct.rs":"e0097d7f947cf9e4612c9450c55ea5075c7f6fcbbf8cac7176449d92eebc9343","tests/enums_unit.rs":"8c075d5897b60b58cb71d6306e7fdd80851f5a147ae3010ba70ea100007364a3","tests/error.rs":"f989a43fad47d61d75da2bc78af6c51bac549f39f14f87a804eea226308ece32","tests/from_generics.rs":"79230ad21e8482cf6e6ceb0c74303bc0cdf77fbb951f46a6ba1006ecf1248fd5","tests/from_type_param.rs":"4369737a9d4c21cfa8595a9159cd5d98d02af3445d8b4085654ad4ce8e8bba3f","tests/from_type_param_default.rs":"a5ee72f22540004e755445c37dd4c425ef12beef496896d608695bae964afe7f","tests/from_variant.rs":"2e804326302a62b979eae963e88f0a2cdb6a21ee9667407c361d178f8c0aadba","tests/generics.rs":"3c0f43b39a8f319b8318e409d3836c7235892ae4f50f5986ea80f69b80a4080b","tests/happy_path.rs":"13cf6cd5f87920d90762fd08e45d9f0bb378563e1c92cf5ffb3ba78decdc4969","tests/multiple.rs":"b76172c396a89414b1669eec2bf854c79a7215fd3b6977123b81591ac6761670","tests/newtype.rs":"c45842fd764174a6a8177851e15445d344ab93bf2124b5f77213780d1306adea","tests/skip.rs":"fd936a5eff92c0a49b0a900e6fcda6b7a10a83dd4096ae2000201ccb3f66a738","tests/split_declaration.rs":"b191ed446bf7b8fdf1d41059354adb4b155523507f37b0d36aed3347617a2492","tests/supports.rs":"acb53d4d810dcd3e46763db13234e4fb42e425cfde2516d9bf5d7b690be72dcc"},"package":"7f000e7b03a0083a30e1f10b1428a530849c21e72b338fa76869b5dbc4b045bf"}
\ No newline at end of file
--- a/third_party/rust/darling/CHANGELOG.md
+++ b/third_party/rust/darling/CHANGELOG.md
@@ -1,12 +1,42 @@
 # Changelog
 
-## Unreleased Features
-_None_
+## v0.8.0
+- Update dependency on `syn` to 0.15 [#44](https://github.com/darling/pull/44). Thanks to @hcpl
+
+## v0.7.0 (July 24, 2018)
+- Update dependencies on `syn` and `proc-macro2`
+- Add `util::IdentString`, which acts as an Ident or its string equivalent
+
+## v0.6.3 (May 22, 2018)
+- Add support for `Uses*` traits in where predicates
+
+## v0.6.2 (May 22, 2018)
+- Add `usage` module for tracking type param and lifetime usage in generic declarations
+  - Add `UsesTypeParams` and `CollectsTypeParams` traits [#37](https://github.com/darling/issues/37)
+  - Add `UsesLifetimes` and `CollectLifetimes` traits [#41](https://github.com/darling/pull/41)
+- Don't add `FromMeta` bounds to type parameters only used by skipped fields [#40](https://github.com/darling/pull/40)
+
+## v0.6.1 (May 17, 2018)
+- Fix an issue where the `syn` update broke shape validation [#36](https://github.com/TedDriggs/darling/issues/36)
+
+## v0.6.0 (May 15, 2018)
+
+### Breaking Changes
+- Renamed `FromMetaItem` to `FromMeta`, and renamed `from_meta_item` method to `from_meta`
+- Added dedicated `derive(FromMetaItem)` which panics and redirects users to `FromMeta`
+
+## v0.5.0 (May 10, 2018)
+- Add `ast::Generics` and `ast::GenericParam` to work with generics in a manner similar to `ast::Data`
+- Add `ast::GenericParamExt` to support alternate representations of generic parameters
+- Add `util::WithOriginal` to get a parsed representation and syn's own struct for a syntax block
+- Add `FromGenerics` and `FromGenericParam` traits (without derive support)
+- Change generated code for `generics` magic field to invoke `FromGenerics` trait during parsing
+- Add `FromTypeParam` trait [#30](https://github.com/TedDriggs/darling/pull/30). Thanks to @upsuper
 
 ## 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)
@@ -31,9 +61,9 @@
 
 - Add `impl FromMetaItem` for integer types [#15](https://github.com/TedDriggs/darling/pull/15)
 
 ## v0.2.0 (June 18, 2017)
 
 - Added support for returning multiple errors from parsing [#5](https://github.com/TedDriggs/darling/pull/5)
 - Derived impls no longer return on first error [#5](https://github.com/TedDriggs/darling/pull/5)
 - Removed default types for `V` and `F` from `ast::Body`
-- Enum variants are automatically converted to snake_case [#12](https://github.com/TedDriggs/darling/pull/12)
\ No newline at end of file
+- Enum variants are automatically converted to snake_case [#12](https://github.com/TedDriggs/darling/pull/12)
--- a/third_party/rust/darling/Cargo.toml
+++ b/third_party/rust/darling/Cargo.toml
@@ -7,27 +7,30 @@
 #
 # 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.4.0"
+version = "0.8.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.4.0"
+documentation = "https://docs.rs/darling/0.8.0"
 readme = "README.md"
 license = "MIT"
 repository = "https://github.com/TedDriggs/darling"
 [dependencies.darling_core]
-version = "=0.4.0"
+version = "=0.8.0"
 
 [dependencies.darling_macro]
-version = "=0.4.0"
+version = "=0.8.0"
+[dev-dependencies.proc-macro2]
+version = "0.4"
+
 [dev-dependencies.quote]
-version = "0.5"
+version = "0.6"
 
 [dev-dependencies.syn]
-version = "0.13"
+version = "0.15"
 [badges.travis-ci]
 repository = "TedDriggs/darling"
--- a/third_party/rust/darling/README.md
+++ b/third_party/rust/darling/README.md
@@ -4,28 +4,28 @@ Darling
 [![Build Status](https://travis-ci.org/TedDriggs/darling.svg?branch=master)](https://travis-ci.org/TedDriggs/darling)
 [![Latest Version](https://img.shields.io/crates/v/darling.svg)](https://crates.io/crates/darling)
 
 `darling` is a crate for proc macro authors, which enables parsing attributes into structs. It is heavily inspired by `serde` both in its internals and in its API.
 
 # Usage
 `darling` provides a set of traits which can be derived or manually implemented.
 
-1. `FromMetaItem` is used to extract values from a meta-item in an attribute. Implementations are likely reusable for many libraries, much like `FromStr` or `serde::Deserialize`. Trait implementations are provided for primitives, some std types, and some `syn` types.
+1. `FromMeta` is used to extract values from a meta-item in an attribute. Implementations are likely reusable for many libraries, much like `FromStr` or `serde::Deserialize`. Trait implementations are provided for primitives, some std types, and some `syn` types.
 1. `FromDeriveInput` is implemented or derived by each proc-macro crate which depends on `darling`. This is the root for input parsing; it gets access to the identity, generics, and visibility of the target type, and can specify which attribute names should be parsed or forwarded from the input AST.
 1. `FromField` is implemented or derived by each proc-macro crate which depends on `darling`. Structs deriving this trait will get access to the identity (if it exists), type, and visibility of the field.
 
 # Example
 
 ```rust,ignore
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
-#[derive(Default, FromMetaItem)]
+#[derive(Default, FromMeta)]
 #[darling(default)]
 pub struct Lorem {
     #[darling(rename = "sit")]
     ipsum: bool,
     dolor: Option<String>,
 }
 
 #[derive(FromDeriveInput)]
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/examples/automatic_bounds.rs
@@ -0,0 +1,77 @@
+#[macro_use]
+extern crate darling;
+
+extern crate syn;
+
+use darling::FromDeriveInput;
+
+#[derive(FromMeta, PartialEq, Eq, Debug)]
+enum Volume {
+    Whisper,
+    Talk,
+    Shout,
+}
+
+/// A more complex example showing the ability to skip at a field or struct
+/// level while still tracking which type parameters need to be bounded.
+/// This can be seen by expanding this example using `cargo expand`.
+#[derive(FromMeta)]
+#[allow(dead_code)]
+enum Emphasis<T> {
+    Constant(Volume),
+    Variable(darling::util::IdentList),
+    #[darling(skip)]
+    PerPhoneme(Option<T>),
+    Strided {
+        #[darling(skip)]
+        step: Vec<T>,
+        #[darling(multiple)]
+        volume: Vec<Volume>,
+    },
+}
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(speak))]
+struct SpeakingOptions<T, U> {
+    max_volume: U,
+    #[darling(skip, default)]
+    additional_data: Vec<T>,
+}
+
+#[derive(Default)]
+struct Phoneme {
+    #[allow(dead_code)]
+    first: String,
+}
+
+// This is probably the holy grail for `darling`'s own internal use-case:
+// Auto-apply `Default` bound to skipped *field* types in `where` clause.
+impl<T, U> Default for SpeakingOptions<T, U>
+where
+    Vec<T>: Default,
+    U: Default,
+{
+    fn default() -> Self {
+        Self {
+            max_volume: Default::default(),
+            additional_data: Default::default(),
+        }
+    }
+}
+
+fn main() {
+    let derive_input = syn::parse_str(
+        r#"
+        #[derive(Speak)]
+        #[speak(max_volume = "shout")]
+        enum HtmlElement {
+            Div(String)
+        }
+    "#,
+    ).unwrap();
+
+    let parsed: SpeakingOptions<Phoneme, Volume> =
+        FromDeriveInput::from_derive_input(&derive_input).unwrap();
+    assert_eq!(parsed.max_volume, Volume::Shout);
+    assert_eq!(parsed.additional_data.len(), 0);
+}
--- a/third_party/rust/darling/examples/consume_fields.rs
+++ b/third_party/rust/darling/examples/consume_fields.rs
@@ -1,39 +1,40 @@
 //! This example shows how to do struct and field parsing using darling.
 
 #[macro_use]
 extern crate darling;
-
+extern crate proc_macro2;
 #[macro_use]
 extern crate quote;
 extern crate syn;
 
 use darling::ast;
 use darling::FromDeriveInput;
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::parse_str;
 
 /// A speaking volume. Deriving `FromMeta` will cause this to be usable
 /// as a string value for a meta-item key.
-#[derive(Debug, Clone, Copy, FromMetaItem)]
+#[derive(Debug, Clone, Copy, FromMeta)]
 #[darling(default)]
 enum Volume {
     Normal,
     Whisper,
     Shout,
 }
 
 impl Default for Volume {
     fn default() -> Self {
         Volume::Normal
     }
 }
 
-/// Support parsing from a full derive input. Unlike FromMetaItem, this isn't
+/// Support parsing from a full derive input. Unlike FromMeta, this isn't
 /// composable; each darling-dependent crate should have its own struct to handle
 /// when its trait is derived.
 #[derive(Debug, FromDeriveInput)]
 // This line says that we want to process all attributes declared with `my_trait`,
 // and that darling should panic if this receiver is given an enum.
 #[darling(attributes(my_trait), supports(struct_any))]
 struct MyInputReceiver {
     /// The struct ident.
@@ -49,17 +50,17 @@ struct MyInputReceiver {
 
     /// The Input Receiver demands a volume, so use `Volume::Normal` if the
     /// caller doesn't provide one.
     #[darling(default)]
     volume: Volume,
 }
 
 impl ToTokens for MyInputReceiver {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let MyInputReceiver {
             ref ident,
             ref generics,
             ref data,
             volume,
         } = *self;
 
         let (imp, ty, wher) = generics.split_for_impl();
@@ -73,50 +74,52 @@ impl ToTokens for MyInputReceiver {
             .iter()
             .enumerate()
             .map(|(i, f)| {
                 // We have to preformat the ident in this case so we can fall back
                 // to the field index for unnamed fields. It's not easy to read,
                 // unfortunately.
                 format!(
                     "{} = {{}}",
-                    f.ident.as_ref().map(|v| format!("{}", v)).unwrap_or_else(
-                        || {
-                            format!("{}", i)
-                        },
-                    )
+                    f.ident
+                        .as_ref()
+                        .map(|v| format!("{}", v))
+                        .unwrap_or_else(|| format!("{}", i))
                 )
             })
             .collect::<Vec<_>>()
             .join(", ");
 
         // Generate the actual values to fill the format string.
         let field_list = fields
             .into_iter()
             .enumerate()
             .map(|(i, f)| {
                 let field_volume = f.volume.unwrap_or(volume);
 
                 // This works with named or indexed fields, so we'll fall back to the index so we can
                 // write the output as a key-value pair.
-                let field_ident = f.ident.as_ref().map(|v| quote!(#v)).unwrap_or_else(|| quote!(#i));
+                let field_ident = f.ident
+                    .as_ref()
+                    .map(|v| quote!(#v))
+                    .unwrap_or_else(|| quote!(#i));
 
                 match field_volume {
                     Volume::Normal => quote!(self.#field_ident),
                     Volume::Shout => {
                         quote!(::std::string::ToString::to_string(&self.#field_ident).to_uppercase())
                     }
                     Volume::Whisper => {
                         quote!(::std::string::ToString::to_string(&self.#field_ident).to_lowercase())
                     }
                 }
             })
             .collect::<Vec<_>>();
 
-        tokens.append_all(quote! {
+        tokens.extend(quote! {
             impl #imp Speak for #ident #ty #wher {
                 fn speak(&self, writer: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                     write!(#fmt_string, #(#field_list),*)
                 }
             }
         });
     }
 }
@@ -147,22 +150,25 @@ pub struct Foo {
 
     baz: i64,
 }"#;
 
     let parsed = parse_str(input).unwrap();
     let receiver = MyInputReceiver::from_derive_input(&parsed).unwrap();
     let tokens = quote!(#receiver);
 
-    println!(r#"
+    println!(
+        r#"
 INPUT:
 
 {}
 
 PARSED AS:
 
 {:?}
 
 EMITS:
 
 {}
-    "#, input, receiver, tokens);
+    "#,
+        input, receiver, tokens
+    );
 }
--- a/third_party/rust/darling/examples/fallible_read.rs
+++ b/third_party/rust/darling/examples/fallible_read.rs
@@ -5,17 +5,17 @@
 //! 1. Using `Result<T, syn::Meta>` to attempt a recovery in imperative code
 //! 1. Using the `map` darling meta-item to post-process the receiver before returning.
 
 #[macro_use]
 extern crate darling;
 
 extern crate syn;
 
-use darling::{FromDeriveInput, FromMetaItem};
+use darling::{FromDeriveInput, FromMeta};
 use syn::parse_str;
 
 #[derive(Debug, FromDeriveInput)]
 #[darling(attributes(my_trait), map = "MyInputReceiver::autocorrect")]
 pub struct MyInputReceiver {
     /// This field must be present and a string or else parsing will panic.
     name: String,
 
@@ -31,24 +31,28 @@ pub struct MyInputReceiver {
 }
 
 impl MyInputReceiver {
     /// This function will be called by `darling` _after_ it's finished parsing the
     /// input but before returning to the caller. This is a good place to initialize
     /// skipped fields or to perform corrections that don't lend themselves to being
     /// done elsewhere.
     fn autocorrect(self) -> Self {
-        let Self { name, frequency, amplitude } = self;
+        let Self {
+            name,
+            frequency,
+            amplitude,
+        } = self;
 
         // Amplitude doesn't have a sign, so if we received a negative number then
         // we'll go ahead and make it positive.
         let amplitude = match amplitude {
             Ok(amp) => amp,
             Err(mi) => {
-                let val: i64 = if let Ok(v) = FromMetaItem::from_meta_item(&mi) {
+                let val: i64 = if let Ok(v) = FromMeta::from_meta(&mi) {
                     v
                 } else {
                     panic!(format!("amplitude should have been an integer"))
                 };
 
                 val.abs() as u64
             }
         };
@@ -64,18 +68,21 @@ impl MyInputReceiver {
 fn main() {
     let input = r#"#[derive(MyTrait)]
 #[my_trait(name="Jon", amplitude = "-1", frequency = "1")]
 pub struct Foo;"#;
 
     let parsed = parse_str(input).unwrap();
     let receiver = MyInputReceiver::from_derive_input(&parsed).unwrap();
 
-    println!(r#"
+    println!(
+        r#"
 INPUT:
 
 {}
 
 PARSED AS:
 
 {:?}
-    "#, input, receiver);
+    "#,
+        input, receiver
+    );
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/examples/supports_struct.rs
@@ -0,0 +1,63 @@
+#[macro_use]
+extern crate darling;
+
+extern crate syn;
+
+use darling::{ast, util, FromDeriveInput};
+use syn::{Ident, Type};
+
+#[derive(Debug, FromField)]
+#[darling(attributes(lorem))]
+pub struct LoremField {
+    ident: Option<Ident>,
+    ty: Type,
+    #[darling(default)]
+    skip: bool,
+}
+
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(lorem), supports(struct_named))]
+pub struct Lorem {
+    ident: Ident,
+    data: ast::Data<util::Ignored, LoremField>,
+}
+
+fn main() {
+    let good_input = r#"#[derive(Lorem)]
+pub struct Foo {
+    #[lorem(skip)]
+    bar: bool,
+
+    baz: i64,
+}"#;
+
+    let bad_input = r#"#[derive(Lorem)]
+    pub struct BadFoo(String, u32);"#;
+
+    let parsed = syn::parse_str(good_input).unwrap();
+    let receiver = Lorem::from_derive_input(&parsed).unwrap();
+    let wrong_shape_parsed = syn::parse_str(bad_input).unwrap();
+    let wrong_shape = Lorem::from_derive_input(&wrong_shape_parsed)
+        .expect_err("Shape was wrong");
+
+    println!(
+        r#"
+INPUT:
+
+{}
+
+PARSED AS:
+
+{:?}
+
+BAD INPUT:
+
+{}
+
+PRODUCED ERROR:
+
+{}
+    "#,
+        good_input, receiver, bad_input, wrong_shape
+    );
+}
--- a/third_party/rust/darling/src/lib.rs
+++ b/third_party/rust/darling/src/lib.rs
@@ -1,80 +1,98 @@
 //! # Darling
 //! Darling is a tool for declarative attribute parsing in proc macro implementations.
 //!
 //!
 //! ## Design
 //! Darling takes considerable design inspiration from [`serde`]. A data structure that can be
-//! read from any attribute implements `FromMetaItem` (or has an implementation automatically 
-//! generated using `derive`). Any crate can provide `FromMetaItem` implementations, even one not
+//! read from any attribute implements `FromMeta` (or has an implementation automatically
+//! generated using `derive`). Any crate can provide `FromMeta` implementations, even one not
 //! specifically geared towards proc-macro authors.
 //!
-//! Proc-macro crates should provide their own structs which implement or derive `FromDeriveInput` and
-//! `FromField` to gather settings relevant to their operation.
+//! Proc-macro crates should provide their own structs which implement or derive `FromDeriveInput`,
+//! `FromField`, `FromVariant`, `FromGenerics`, _et alia_ to gather settings relevant to their operation.
 //!
 //! ## Attributes
 //! There are a number of attributes that `darling` exposes to enable finer-grained control over the code
 //! it generates.
 //!
 //! * **Field renaming**: You can use `#[darling(rename="new_name")]` on a field to change the name Darling looks for.
 //!   You can also use `#[darling(rename_all="...")]` at the struct or enum level to apply a casing rule to all fields or variants.
 //! * **Map function**: You can use `#[darling(map="path::to::function")]` to run code on a field before its stored in the struct.
 //! * **Default values**: You can use `#[darling(default)]` at the type or field level to use that type's default value to fill
 //!   in values not specified by the caller.
 //! * **Skipped fields**: You can skip a variant or field using `#[darling(skip)]`. Fields marked with this will fall back to
 //!   `Default::default()` for their value, but you can override that with an explicit default or a value from the type-level default.
 //!
 //! ## Forwarded Fields
-//! The traits `FromDeriveInput` and `FromField` support forwarding fields from the input AST directly 
-//! to the derived struct. These fields are matched up by identifier **before** `rename` attribute values are
-//! considered. The deriving struct is responsible for making sure the types of fields it does declare match this
-//! table.
+//! All derivable traits except `FromMeta` support forwarding some fields from the input AST to the derived struct.
+//! These fields are matched up by identifier **before** `rename` attribute values are considered,
+//! allowing you to use their names for your own properties.
+//! The deriving struct is responsible for making sure the types of fields it chooses to declare are compatible with this table.
 //!
 //! A deriving struct is free to include or exclude any of the fields below.
 //!
 //! ### `FromDeriveInput`
 //! |Field name|Type|Meaning|
 //! |---|---|---|
 //! |`ident`|`syn::Ident`|The identifier of the passed-in type|
 //! |`vis`|`syn::Visibility`|The visibility of the passed-in type|
-//! |`generics`|`syn::Generics`|The generics of the passed-in type|
-//! |`body`|`darling::ast::Data`|The body of the passed-in type|
+//! |`generics`|`T: darling::FromGenerics`|The generics of the passed-in type. This can be `syn::Generics`, `darling::ast::Generics`, or any compatible type.|
+//! |`data`|`darling::ast::Data`|The body of the passed-in type|
 //! |`attrs`|`Vec<syn::Attribute>`|The forwarded attributes from the passed in type. These are controlled using the `forward_attrs` attribute.|
 //!
 //! ### `FromField`
 //! |Field name|Type|Meaning|
 //! |---|---|---|
 //! |`ident`|`syn::Ident`|The identifier of the passed-in field|
 //! |`vis`|`syn::Visibility`|The visibility of the passed-in field|
 //! |`ty`|`syn::Type`|The type of the passed-in field|
 //! |`attrs`|`Vec<syn::Attribute>`|The forwarded attributes from the passed in field. These are controlled using the `forward_attrs` attribute.|
+//!
+//! ### `FromTypeParam`
+//! |Field name|Type|Meaning|
+//! |---|---|---|
+//! |`ident`|`syn::Ident`|The identifier of the passed-in type param|
+//! |`bounds`|`Vec<syn::TypeParamBound>`|The bounds applied to the type param|
+//! |`default`|`Option<syn::Type>`|The default type of the parameter, if one exists|
+//! |`attrs`|`Vec<syn::Attribute>`|The forwarded attributes from the passed in type param. These are controlled using the `forward_attrs` attribute.|
 
 extern crate core;
 extern crate darling_core;
 
 #[allow(unused_imports)]
 #[macro_use]
 extern crate darling_macro;
 
 #[doc(hidden)]
 pub use darling_macro::*;
 
 #[doc(inline)]
-pub use darling_core::{FromMetaItem, FromDeriveInput, FromField, FromVariant};
+pub use darling_core::{FromDeriveInput, FromField, FromGenericParam, FromGenerics, FromMeta,
+                       FromTypeParam, FromVariant};
+
+#[doc(inline)]
+pub use darling_core::{Error, Result};
 
 #[doc(inline)]
-pub use darling_core::{Result, Error};
+pub use darling_core::{ast, error, usage, util};
 
-#[doc(inline)]
-pub use darling_core::{ast, error, util};
+// XXX exported so that `ExtractAttribute::extractor` can convert a path into tokens.
+// This is likely to change in the future, so only generated code should depend on this export.
+#[doc(hidden)]
+pub use darling_core::ToTokens;
 
 /// Core/std trait re-exports. This should help produce generated code which doesn't
 /// depend on `std` unnecessarily, and avoids problems caused by aliasing `std` or any
 /// of the referenced types.
 #[doc(hidden)]
-pub mod export {    
-    pub use ::core::convert::From;
-    pub use ::core::option::Option::{self, Some, None};
-    pub use ::core::result::Result::{self, Ok, Err};
-    pub use ::core::default::Default;
-    pub use ::std::vec::Vec;
+pub mod export {
+    pub use core::convert::From;
+    pub use core::default::Default;
+    pub use core::option::Option::{self, None, Some};
+    pub use core::result::Result::{self, Err, Ok};
+    pub use std::vec::Vec;
+    pub use std::string::ToString;
 }
+
+#[macro_use]
+mod macros_public;
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/src/macros_public.rs
@@ -0,0 +1,98 @@
+//! Macros that should be exported from both `darling_core` and `darling`.
+//! Note that these are **sym-linked** into the main code, and so cannot declare on items that are exported differently
+//! in `darling_core` vs. `darling`.
+
+/// Generator for `UsesTypeParam` impls that unions the used type parameters of the selected fields.
+///
+/// # Usage
+/// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
+/// fields for the rest of its arguments.
+///
+/// The type of each passed-in field must implement `UsesTypeParams`, or the resulting code won't compile.
+///
+/// ```rust
+/// # extern crate syn;
+/// #
+/// # #[macro_use]
+/// # extern crate darling_core;
+/// #
+/// struct MyField {
+///     ty: syn::Type,
+/// }
+///
+/// uses_type_params!(MyField, ty);
+///
+/// fn main() {
+///     // no test run
+/// }
+/// ```
+///
+/// `darling` cannot derive this trait automatically, as it doesn't know which information extracted from
+/// proc-macro input is meant to constitute "using" the type parameter, but crate consumers should
+/// implement it by hand or using the macro.
+#[macro_export]
+macro_rules! uses_type_params {
+    ($impl_type:ty, $accessor:ident) => {
+        impl $crate::usage::UsesTypeParams for $impl_type {
+            fn uses_type_params<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::IdentSet
+            ) -> $crate::usage::IdentRefSet<'gen> {
+                self.$accessor.uses_type_params(options, type_set)
+            }
+        }
+    };
+    ($impl_type:ty, $first:ident, $($field:ident),+) => {
+        impl $crate::usage::UsesTypeParams for $impl_type {
+            fn uses_type_params<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::IdentSet
+            ) -> $crate::usage::IdentRefSet<'gen> {
+                let mut hits = self.$first.uses_type_params(options, type_set);
+                $(
+                    hits.extend(self.$field.uses_type_params(options, type_set));
+                )*
+                hits
+            }
+        }
+    };
+}
+
+/// Generator for `UsesLifetimes` impls that unions the used lifetimes of the selected fields.
+///
+/// # Usage
+/// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
+/// fields for the rest of its arguments.
+///
+/// The type of each passed-in field must implement `UsesLifetimes`, or the resulting code won't compile.
+#[macro_export]
+macro_rules! uses_lifetimes {
+    ($impl_type:ty, $accessor:ident) => {
+        impl $crate::usage::UsesLifetimes for $impl_type {
+            fn uses_lifetimes<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::LifetimeSet
+            ) -> $crate::usage::LifetimeRefSet<'gen> {
+                self.$accessor.uses_lifetimes(options, type_set)
+            }
+        }
+    };
+    ($impl_type:ty, $first:ident, $($field:ident),+) => {
+        impl $crate::usage::UsesLifetimes for $impl_type {
+            fn uses_lifetimes<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::LifetimeSet
+            ) -> $crate::usage::LifetimeRefSet<'gen> {
+                let mut hits = self.$first.uses_lifetimes(options, type_set);
+                $(
+                    hits.extend(self.$field.uses_lifetimes(options, type_set));
+                )*
+                hits
+            }
+        }
+    };
+}
--- a/third_party/rust/darling/tests/accrue_errors.rs
+++ b/third_party/rust/darling/tests/accrue_errors.rs
@@ -11,99 +11,104 @@ use darling::FromDeriveInput;
 #[derive(Debug, FromDeriveInput)]
 #[darling(attributes(accrue))]
 struct Lorem {
     ipsum: String,
     dolor: Dolor,
     data: ast::Data<(), LoremField>,
 }
 
-#[derive(Debug, FromMetaItem)]
+#[derive(Debug, FromMeta)]
 struct Dolor {
-    sit: bool
+    sit: bool,
 }
 
 #[derive(Debug, FromField)]
 #[darling(attributes(accrue))]
 struct LoremField {
     ident: Option<syn::Ident>,
     aliased_as: syn::Ident,
 }
 
 #[test]
 fn bad_type_and_missing_fields() {
-    let input = syn::parse_str(r#"
+    let input = syn::parse_str(
+        r#"
     #[accrue(ipsum = true, dolor(amet = "Hi"))]
     pub struct NonConforming {
         foo: ()
     }
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let s_result: ::darling::Error = Lorem::from_derive_input(&input).unwrap_err();
     //assert_eq!(3, s_result.len());
     let err = s_result.flatten();
     println!("{}", err);
     assert_eq!(3, err.len());
 }
 
 #[test]
 fn body_only_issues() {
-    let input = syn::parse_str(r#"
+    let input = syn::parse_str(
+        r#"
     #[accrue(ipsum = "Hello", dolor(sit))]
     pub struct NonConforming {
         foo: (),
         bar: bool,
     }
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let s_err: ::darling::Error = Lorem::from_derive_input(&input).unwrap_err();
     println!("{:?}", s_err);
     assert_eq!(2, s_err.len());
 }
 
-#[derive(Debug, FromMetaItem)]
+#[derive(Debug, FromMeta)]
 enum Week {
     Monday,
-    Tuesday {
-        morning: bool,
-        afternoon: String,
-    },
+    Tuesday { morning: bool, afternoon: String },
     Wednesday(Dolor),
 }
 
 #[derive(Debug, FromDeriveInput)]
 #[darling(attributes(accrue))]
 struct Month {
-    schedule: Week
+    schedule: Week,
 }
 
 #[test]
 fn error_in_enum_fields() {
-    let input = syn::parse_str(r#"
+    let input = syn::parse_str(
+        r#"
     #[accrue(schedule(tuesday(morning = "yes")))]
     pub struct NonConforming {
         foo: (),
         bar: bool,
     }
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let s_err: ::darling::Error = Month::from_derive_input(&input).unwrap_err();
     assert_eq!(2, s_err.len());
     let err = s_err.flatten();
     // TODO add tests to check location path is correct
     println!("{}", err);
 }
 
 #[test]
 fn error_in_newtype_variant() {
-    let input = syn::parse_str(r#"
+    let input = syn::parse_str(
+        r#"
     #[accrue(schedule(wednesday(sit = "yes")))]
     pub struct NonConforming {
         foo: (),
         bar: bool,
     }
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let s_err: ::darling::Error = Month::from_derive_input(&input).unwrap_err();
     assert_eq!(1, s_err.len());
     println!("{}", s_err);
     println!("{}", s_err.flatten());
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/tests/computed_bound.rs
@@ -0,0 +1,46 @@
+#[macro_use]
+extern crate darling;
+extern crate syn;
+
+use darling::FromDeriveInput;
+
+fn parse<T: FromDeriveInput>(src: &str) -> T {
+    let ast = syn::parse_str(src).unwrap();
+    FromDeriveInput::from_derive_input(&ast).unwrap()
+}
+
+#[derive(FromMeta, PartialEq, Eq, Debug)]
+enum Volume {
+    Whisper,
+    Talk,
+    Shout,
+}
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(speak))]
+struct SpeakingOptions<T: Default, U> {
+    max_volume: U,
+    #[darling(skip)]
+    #[allow(dead_code)]
+    additional_data: T,
+}
+
+#[derive(Default)]
+struct Phoneme {
+    #[allow(dead_code)]
+    first: String,
+}
+
+#[test]
+fn skipped_field() {
+    let parsed: SpeakingOptions<Phoneme, Volume> = parse(
+        r#"
+        #[derive(Speak)]
+        #[speak(max_volume = "shout")]
+        enum HtmlElement {
+            Div(String)
+        }
+    "#,
+    );
+    assert_eq!(parsed.max_volume, Volume::Shout);
+}
--- a/third_party/rust/darling/tests/custom_bound.rs
+++ b/third_party/rust/darling/tests/custom_bound.rs
@@ -1,25 +1,25 @@
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
 use std::ops::Add;
 
-#[derive(Debug, Clone, FromMetaItem)]
-#[darling(bound = "T: FromMetaItem + Add")]
+#[derive(Debug, Clone, FromMeta)]
+#[darling(bound = "T: FromMeta + Add")]
 struct Wrapper<T>(pub T);
 
 impl<T: Add> Add for Wrapper<T> {
     type Output = Wrapper<<T as Add>::Output>;
     fn add(self, rhs: Self) -> Wrapper<<T as Add>::Output> {
         Wrapper(self.0 + rhs.0)
     }
 }
 
 #[derive(Debug, FromDeriveInput)]
-#[darling(attributes(hello), bound = "Wrapper<T>: Add, T: FromMetaItem")]
+#[darling(attributes(hello), bound = "Wrapper<T>: Add, T: FromMeta")]
 struct Foo<T> {
     lorem: Wrapper<T>,
 }
 
 #[test]
 fn expansion() {}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/tests/defaults.rs
@@ -0,0 +1,32 @@
+#[macro_use]
+extern crate darling;
+#[macro_use]
+extern crate quote;
+#[macro_use]
+extern crate syn;
+
+use darling::FromDeriveInput;
+
+mod foo {
+    pub mod bar {
+        pub fn init() -> String {
+            String::from("hello")
+        }
+    }
+}
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(speak))]
+pub struct SpeakerOpts {
+    #[darling(default="foo::bar::init")]
+    first_word: String,
+}
+
+#[test]
+fn path_default() {
+    let speaker: SpeakerOpts = FromDeriveInput::from_derive_input(&parse_quote! {
+        struct Foo;
+    }).expect("Unit struct with no attrs should parse");
+
+    assert_eq!(speaker.first_word, "hello");
+}
\ No newline at end of file
--- a/third_party/rust/darling/tests/enums_newtype.rs
+++ b/third_party/rust/darling/tests/enums_newtype.rs
@@ -1,24 +1,24 @@
 #[macro_use]
 extern crate darling;
 
 use darling::FromDeriveInput;
 
 extern crate syn;
 
-#[derive(Debug, Default, PartialEq, Eq, FromMetaItem)]
+#[derive(Debug, Default, PartialEq, Eq, FromMeta)]
 #[darling(default)]
 pub struct Amet {
     hello: bool,
     world: String,
 }
 
-#[derive(Debug, PartialEq, Eq, FromMetaItem)]
-#[darling(rename_all="snake_case")]
+#[derive(Debug, PartialEq, Eq, FromMeta)]
+#[darling(rename_all = "snake_case")]
 pub enum Lorem {
     Ipsum(bool),
     Dolor(String),
     Sit(Amet),
 }
 
 #[derive(Debug, PartialEq, Eq, FromDeriveInput)]
 #[darling(attributes(hello))]
@@ -29,63 +29,76 @@ pub struct Holder {
 impl PartialEq<Lorem> for Holder {
     fn eq(&self, other: &Lorem) -> bool {
         self.lorem == *other
     }
 }
 
 #[test]
 fn bool_word() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem(ipsum))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Ipsum(true));
 }
 
 #[test]
 fn bool_literal() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem(ipsum = false))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Ipsum(false));
 }
 
 #[test]
 fn string_literal() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem(dolor = "Hello"))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Holder::from_derive_input(&di).unwrap();
     assert_eq!(pr, Lorem::Dolor("Hello".to_string()));
 }
 
 #[test]
 fn struct_nested() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem(sit(world = "Hello", hello = false)))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Holder::from_derive_input(&di).unwrap();
-    assert_eq!(pr, Lorem::Sit(Amet {
-        hello: false,
-        world: "Hello".to_string(),
-    }));
+    assert_eq!(
+        pr,
+        Lorem::Sit(Amet {
+            hello: false,
+            world: "Hello".to_string(),
+        })
+    );
 }
 
 #[test]
 #[should_panic]
 fn format_mismatch() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem(dolor(world = "Hello", hello = false)))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     Holder::from_derive_input(&di).unwrap();
 }
--- a/third_party/rust/darling/tests/enums_struct.rs
+++ b/third_party/rust/darling/tests/enums_struct.rs
@@ -1,23 +1,16 @@
 //! Test expansion of enums which have struct variants.
 
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
-#[derive(Debug, FromMetaItem)]
-#[darling(rename_all="snake_case")]
+#[derive(Debug, FromMeta)]
+#[darling(rename_all = "snake_case")]
 enum Message {
-    Hello {
-        user: String,
-        silent: bool
-    },
+    Hello { user: String, silent: bool },
     Ping,
-    Goodbye {
-        user: String,
-    }
+    Goodbye { user: String },
 }
 
 #[test]
-fn expansion() {
-    
-}
\ No newline at end of file
+fn expansion() {}
--- a/third_party/rust/darling/tests/enums_unit.rs
+++ b/third_party/rust/darling/tests/enums_unit.rs
@@ -1,18 +1,16 @@
 //! Test expansion of enum variants which have no associated data.
 
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
-#[derive(Debug, FromMetaItem)]
-#[darling(rename_all="snake_case")]
+#[derive(Debug, FromMeta)]
+#[darling(rename_all = "snake_case")]
 enum Pattern {
     Owned,
     Immutable,
-    Mutable
+    Mutable,
 }
 
 #[test]
-fn expansion() {
-
-}
\ No newline at end of file
+fn expansion() {}
--- a/third_party/rust/darling/tests/error.rs
+++ b/third_party/rust/darling/tests/error.rs
@@ -1,16 +1,16 @@
 //! In case of bad input, parsing should fail. The error should have locations set in derived implementations.
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
 use darling::FromDeriveInput;
 
-#[derive(Debug, FromMetaItem)]
+#[derive(Debug, FromMeta)]
 struct Dolor {
     #[darling(rename = "amet")]
     sit: bool,
     world: bool,
 }
 
 #[derive(Debug, FromDeriveInput)]
 #[darling(from_ident, attributes(hello))]
@@ -28,25 +28,29 @@ impl From<syn::Ident> for Lorem {
                 world: true,
             },
         }
     }
 }
 
 #[test]
 fn parsing_fail() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(ipsum(amet = "yes", world = false))]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     println!("{}", Lorem::from_derive_input(&di).unwrap_err());
 }
 
 #[test]
 fn missing_field() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(ipsum(amet = true))]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     println!("{}", Lorem::from_derive_input(&di).unwrap_err());
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/tests/from_generics.rs
@@ -0,0 +1,186 @@
+//! Tests for `FromGenerics`, and - indirectly - `FromGenericParam`.
+//! These tests assume `FromTypeParam` is working and only look at whether the wrappers for magic
+//! fields are working as expected.
+
+#[macro_use]
+extern crate darling;
+extern crate syn;
+
+use darling::ast::{self, GenericParamExt};
+use darling::util::{Ignored, WithOriginal};
+use darling::{FromDeriveInput, Result};
+
+#[derive(FromDeriveInput)]
+#[darling(attributes(lorem))]
+struct MyReceiver {
+    pub ident: syn::Ident,
+    pub generics: ast::Generics<ast::GenericParam<MyTypeParam>>,
+}
+
+#[derive(FromTypeParam)]
+#[darling(attributes(lorem))]
+struct MyTypeParam {
+    pub ident: syn::Ident,
+    #[darling(default)]
+    pub foo: bool,
+    #[darling(default)]
+    pub bar: Option<String>,
+}
+
+fn fdi<T: FromDeriveInput>(src: &str) -> Result<T> {
+    FromDeriveInput::from_derive_input(&syn::parse_str(src).expect("Source parses"))
+}
+
+/// Verify that `ast::Generics` is populated correctly when there is no generics declaration
+#[test]
+fn no_generics() {
+    let rec: MyReceiver = fdi("struct Baz;").expect("Input is well-formed");
+    assert!(rec.generics.where_clause.is_none());
+    assert_eq!(rec.generics.params.len(), 0);
+}
+
+#[test]
+fn expand_some() {
+    let rec: MyReceiver = fdi(r#"
+        struct Baz<
+            'a,
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(&'a T, U);
+    "#)
+        .expect("Input is well-formed");
+    assert!(rec.generics.where_clause.is_none());
+
+    // Make sure we've preserved the lifetime def, though we don't do anything with it.
+    assert!(rec.generics.params[0].as_lifetime_def().is_some());
+
+    let mut ty_param_iter = rec.generics.type_params();
+
+    let first = ty_param_iter
+        .next()
+        .expect("type_params should not be empty");
+    assert!(first.bar.is_none());
+    assert!(first.foo);
+    assert_eq!(first.ident, "T");
+
+    let second = ty_param_iter
+        .next()
+        .expect("type_params should have a second value");
+    assert_eq!(
+        second
+            .bar
+            .as_ref()
+            .expect("Second type param should set bar"),
+        "x"
+    );
+    assert_eq!(second.foo, false);
+    assert_eq!(second.ident, "U");
+}
+
+/// Verify ≤0.4.1 behavior - where `generics` had to be `syn::Generics` - keeps working.
+#[test]
+fn passthrough() {
+    #[derive(FromDeriveInput)]
+    struct PassthroughReceiver {
+        pub generics: syn::Generics,
+    }
+
+    let rec: PassthroughReceiver = fdi(r#"
+        struct Baz<
+            'a,
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(&'a T, U);
+    "#)
+        .expect("Input is well-formed");
+
+    let mut type_param_iter = rec.generics.type_params();
+    assert!(type_param_iter.next().is_some());
+}
+
+/// Verify that `where_clause` is passed through when it exists.
+/// As of 0.4.1, there is no `FromWhereClause` trait, so other types aren't supported
+/// for that field.
+#[test]
+fn where_clause() {
+    let rec: MyReceiver = fdi(r#"
+        struct Baz<
+            'a,
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(&'a T, U) where T: Into<String>;
+    "#)
+        .expect("Input is well-formed");
+
+    assert!(rec.generics.where_clause.is_some());
+}
+
+/// Test that `WithOriginal` works for generics.
+#[test]
+fn with_original() {
+    #[derive(FromDeriveInput)]
+    struct WorigReceiver {
+        generics: WithOriginal<ast::Generics<ast::GenericParam<MyTypeParam>>, syn::Generics>,
+    }
+
+    let rec: WorigReceiver = fdi(r#"
+        struct Baz<
+            'a,
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(&'a T, U) where T: Into<String>;
+    "#)
+        .expect("Input is well-formed");
+
+    // Make sure we haven't lost anything in the conversion
+    assert_eq!(rec.generics.parsed.params.len(), 3);
+    assert_eq!(
+        rec.generics
+            .original
+            .params
+            .iter()
+            .collect::<Vec<_>>()
+            .len(),
+        3
+    );
+
+    let parsed_t: &MyTypeParam = rec.generics.parsed.params[1]
+        .as_type_param()
+        .expect("Second argument should be type param");
+
+    // Make sure the first type param in each case is T
+    assert_eq!(parsed_t.ident, "T");
+    assert_eq!(
+        rec.generics
+            .original
+            .type_params()
+            .next()
+            .expect("First type param should exist")
+            .ident,
+        "T"
+    );
+
+    // Make sure we actually parsed the first type param
+    assert!(parsed_t.foo);
+    assert!(parsed_t.bar.is_none());
+}
+
+/// Make sure generics can be ignored
+#[test]
+fn ignored() {
+    #[derive(FromDeriveInput)]
+    struct IgnoredReceiver {
+        generics: Ignored,
+    }
+
+    let rec: IgnoredReceiver = fdi(r#"
+        struct Baz<
+            'a,
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(&'a T, U) where T: Into<String>;
+    "#)
+        .expect("Input is well-formed");
+
+    assert_eq!(Ignored, rec.generics);
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/tests/from_type_param.rs
@@ -0,0 +1,63 @@
+#[macro_use]
+extern crate darling;
+extern crate syn;
+
+use darling::FromTypeParam;
+use syn::{DeriveInput, GenericParam, Ident, TypeParam};
+
+#[darling(attributes(lorem), from_ident)]
+#[derive(FromTypeParam)]
+struct Lorem {
+    ident: Ident,
+    bounds: Vec<syn::TypeParamBound>,
+    foo: bool,
+    bar: Option<String>,
+}
+
+impl From<Ident> for Lorem {
+    fn from(ident: Ident) -> Self {
+        Lorem {
+            ident,
+            foo: false,
+            bar: None,
+            bounds: Default::default(),
+        }
+    }
+}
+
+fn extract_type(param: &GenericParam) -> &TypeParam {
+    match *param {
+        GenericParam::Type(ref ty) => ty,
+        _ => unreachable!("Not a type param"),
+    }
+}
+
+#[test]
+fn expand_many() {
+    let di: DeriveInput = syn::parse_str(
+        r#"
+        struct Baz<
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized
+        >(T, U);
+    "#,
+    ).unwrap();
+    let params = di.generics.params;
+
+    {
+        let ty = extract_type(&params[0]);
+        let lorem = Lorem::from_type_param(ty).unwrap();
+        assert_eq!(lorem.ident, "T");
+        assert_eq!(lorem.foo, true);
+        assert_eq!(lorem.bar, None);
+    }
+
+    {
+        let ty = extract_type(&params[1]);
+        let lorem = Lorem::from_type_param(ty).unwrap();
+        assert_eq!(lorem.ident, "U");
+        assert_eq!(lorem.foo, false);
+        assert_eq!(lorem.bar, Some("x".to_string()));
+        assert_eq!(lorem.bounds.len(), 2);
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling/tests/from_type_param_default.rs
@@ -0,0 +1,58 @@
+#[macro_use]
+extern crate darling;
+extern crate syn;
+
+use darling::FromTypeParam;
+use syn::{DeriveInput, GenericParam, TypeParam};
+
+#[darling(attributes(lorem), default)]
+#[derive(Default, FromTypeParam)]
+struct Lorem {
+    foo: bool,
+    bar: Option<String>,
+    default: Option<syn::Type>,
+}
+
+fn extract_type(param: &GenericParam) -> &TypeParam {
+    match *param {
+        GenericParam::Type(ref ty) => ty,
+        _ => unreachable!("Not a type param"),
+    }
+}
+
+#[test]
+fn expand_many() {
+    let di: DeriveInput = syn::parse_str(
+        r#"
+        struct Baz<
+            #[lorem(foo)] T,
+            #[lorem(bar = "x")] U: Eq + ?Sized,
+            #[lorem(foo = false)] V = (),
+        >(T, U, V);
+    "#,
+    ).unwrap();
+    let params = di.generics.params;
+
+    {
+        let ty = extract_type(&params[0]);
+        let lorem = Lorem::from_type_param(ty).unwrap();
+        assert_eq!(lorem.foo, true);
+        assert_eq!(lorem.bar, None);
+    }
+
+    {
+        let ty = extract_type(&params[1]);
+        let lorem = Lorem::from_type_param(ty).unwrap();
+        assert_eq!(lorem.foo, false);
+        assert_eq!(lorem.bar, Some("x".to_string()));
+        assert!(lorem.default.is_none());
+    }
+
+    {
+        let ty = extract_type(&params[2]);
+        let lorem = Lorem::from_type_param(ty).unwrap();
+        assert_eq!(lorem.foo, false);
+        assert_eq!(lorem.bar, None);
+        assert!(lorem.default.is_some());
+    }
+}
--- a/third_party/rust/darling/tests/from_variant.rs
+++ b/third_party/rust/darling/tests/from_variant.rs
@@ -19,11 +19,9 @@ impl From<syn::Ident> for Lorem {
             into: Default::default(),
             skip: Default::default(),
             fields: darling::ast::Style::Unit.into(),
         }
     }
 }
 
 #[test]
-fn expansion() {
-
-}
\ No newline at end of file
+fn expansion() {}
--- a/third_party/rust/darling/tests/generics.rs
+++ b/third_party/rust/darling/tests/generics.rs
@@ -1,25 +1,26 @@
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
 use darling::FromDeriveInput;
 
-#[derive(Debug, Clone, FromMetaItem)]
+#[derive(Debug, Clone, FromMeta)]
 struct Wrapper<T>(pub T);
 
 #[derive(Debug, FromDeriveInput)]
 #[darling(attributes(hello))]
 struct Foo<T> {
     lorem: Wrapper<T>,
 }
 
 #[test]
 fn expansion() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(lorem = "Hello")]
         pub struct Foo;
-    "#)
-        .unwrap();
+    "#,
+    ).unwrap();
 
     let _parsed = Foo::<String>::from_derive_input(&di).unwrap();
 }
--- a/third_party/rust/darling/tests/happy_path.rs
+++ b/third_party/rust/darling/tests/happy_path.rs
@@ -3,68 +3,78 @@ extern crate darling;
 
 #[macro_use]
 extern crate syn;
 #[macro_use]
 extern crate quote;
 
 use darling::FromDeriveInput;
 
-#[derive(Default, FromMetaItem, PartialEq, Debug)]
+#[derive(Default, FromMeta, PartialEq, Debug)]
 #[darling(default)]
 struct Lorem {
     ipsum: bool,
     dolor: Option<String>,
 }
 
 #[derive(FromDeriveInput, PartialEq, Debug)]
 #[darling(attributes(darling_demo))]
 struct Core {
     ident: syn::Ident,
     vis: syn::Visibility,
     generics: syn::Generics,
-    lorem: Lorem
+    lorem: Lorem,
 }
 
 #[derive(FromDeriveInput, PartialEq, Debug)]
 #[darling(attributes(darling_demo))]
 struct TraitCore {
     ident: syn::Ident,
     generics: syn::Generics,
     lorem: Lorem,
 }
 
 #[test]
 fn simple() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[derive(Foo)]
         #[darling_demo(lorem(ipsum))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
-    assert_eq!(Core::from_derive_input(&di).unwrap(), Core {
-        ident: syn::Ident::from("Bar"),
-        vis: parse_quote!(pub),
-        generics: Default::default(),
-        lorem: Lorem {
-            ipsum: true,
-            dolor: None,
+    assert_eq!(
+        Core::from_derive_input(&di).unwrap(),
+        Core {
+            ident: parse_quote!(Bar),
+            vis: parse_quote!(pub),
+            generics: Default::default(),
+            lorem: Lorem {
+                ipsum: true,
+                dolor: None,
+            },
         }
-    });
+    );
 }
 
 #[test]
 fn trait_type() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[derive(Foo)]
         #[darling_demo(lorem(dolor = "hello"))]
         pub struct Bar;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
-    assert_eq!(TraitCore::from_derive_input(&di).unwrap(), TraitCore {
-        ident: syn::Ident::from("Bar"),
-        generics: Default::default(),
-        lorem: Lorem {
-            ipsum: false,
-            dolor: Some("hello".to_owned()),
+    assert_eq!(
+        TraitCore::from_derive_input(&di).unwrap(),
+        TraitCore {
+            ident: parse_quote!(Bar),
+            generics: Default::default(),
+            lorem: Lorem {
+                ipsum: false,
+                dolor: Some("hello".to_owned()),
+            }
         }
-    });
+    );
 }
--- a/third_party/rust/darling/tests/multiple.rs
+++ b/third_party/rust/darling/tests/multiple.rs
@@ -7,24 +7,29 @@ use darling::FromDeriveInput;
 #[derive(FromDeriveInput)]
 #[darling(attributes(hello))]
 #[allow(dead_code)]
 struct Lorem {
     ident: syn::Ident,
     ipsum: Ipsum,
 }
 
-#[derive(FromMetaItem)]
+#[derive(FromMeta)]
 struct Ipsum {
     #[darling(multiple)]
     dolor: Vec<String>,
 }
 
 #[test]
 fn expand_many() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[hello(ipsum(dolor = "Hello", dolor = "World"))]
         pub struct Baz;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let lorem: Lorem = Lorem::from_derive_input(&di).unwrap();
-    assert_eq!(lorem.ipsum.dolor, vec!["Hello".to_string(), "World".to_string()]);
+    assert_eq!(
+        lorem.ipsum.dolor,
+        vec!["Hello".to_string(), "World".to_string()]
+    );
 }
--- a/third_party/rust/darling/tests/newtype.rs
+++ b/third_party/rust/darling/tests/newtype.rs
@@ -1,30 +1,32 @@
-//! A newtype struct should be able to derive `FromMetaItem` if its member implements it.
+//! A newtype struct should be able to derive `FromMeta` if its member implements it.
 
 #[macro_use]
 extern crate darling;
 
 extern crate syn;
 
 use darling::FromDeriveInput;
 
-#[derive(Debug, FromMetaItem, PartialEq, Eq)]
+#[derive(Debug, FromMeta, PartialEq, Eq)]
 struct Lorem(bool);
 
 #[derive(Debug, FromDeriveInput)]
 #[darling(attributes(newtype))]
 struct DemoContainer {
-    lorem: Lorem
+    lorem: Lorem,
 }
 
 #[test]
 fn generated() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[derive(Baz)]
         #[newtype(lorem = false)]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let c = DemoContainer::from_derive_input(&di).unwrap();
 
     assert_eq!(c.lorem, Lorem(false));
 }
--- a/third_party/rust/darling/tests/skip.rs
+++ b/third_party/rust/darling/tests/skip.rs
@@ -11,36 +11,41 @@ use darling::FromDeriveInput;
 pub struct Lorem {
     ipsum: String,
 
     #[darling(skip)]
     dolor: u8,
 }
 
 /// Verify variant-level and field-level skip work correctly for enums.
-#[derive(Debug, FromMetaItem)]
+#[derive(Debug, FromMeta)]
 pub enum Sit {
     Amet(bool),
 
     #[darling(skip)]
     Foo {
         hello: bool,
     },
 
     Bar {
         hello: bool,
         #[darling(skip)]
-        world: u8
-    }
+        world: u8,
+    },
 }
 
 #[test]
 fn verify_skipped_field_not_required() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[skip_test(ipsum = "Hello")]
         struct Baz;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
-    assert_eq!(Lorem::from_derive_input(&di).unwrap(), Lorem {
-        ipsum: "Hello".to_string(),
-        dolor: 0,
-    });
+    assert_eq!(
+        Lorem::from_derive_input(&di).unwrap(),
+        Lorem {
+            ipsum: "Hello".to_string(),
+            dolor: 0,
+        }
+    );
 }
--- a/third_party/rust/darling/tests/split_declaration.rs
+++ b/third_party/rust/darling/tests/split_declaration.rs
@@ -13,49 +13,67 @@ use darling::{Error, FromDeriveInput};
 #[darling(attributes(split))]
 struct Lorem {
     foo: String,
     bar: bool,
 }
 
 #[test]
 fn split_attributes_accrue_to_instance() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[split(foo = "Hello")]
         #[split(bar)]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let parsed = Lorem::from_derive_input(&di).unwrap();
-    assert_eq!(parsed, Lorem {
-        foo: "Hello".to_string(),
-        bar: true,
-    });
+    assert_eq!(
+        parsed,
+        Lorem {
+            foo: "Hello".to_string(),
+            bar: true,
+        }
+    );
 }
 
 #[test]
 fn duplicates_across_split_attrs_error() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[split(foo = "Hello")]
         #[split(foo = "World", bar)]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Lorem::from_derive_input(&di);
-    assert_eq!(pr.unwrap_err().to_string(), Error::duplicate_field("foo").to_string());
+    assert_eq!(
+        pr.unwrap_err().to_string(),
+        Error::duplicate_field("foo").to_string()
+    );
 }
 
 #[test]
 fn multiple_errors_accrue_to_instance() {
-    let di = syn::parse_str(r#"
+    let di = syn::parse_str(
+        r#"
         #[split(foo = "Hello")]
         #[split(foo = "World")]
         pub struct Foo;
-    "#).unwrap();
+    "#,
+    ).unwrap();
 
     let pr = Lorem::from_derive_input(&di);
     let err: Error = pr.unwrap_err();
     assert_eq!(2, err.len());
     let mut errs = err.into_iter();
-    assert_eq!(errs.next().unwrap().to_string(), Error::duplicate_field("foo").to_string());
-    assert_eq!(errs.next().unwrap().to_string(), Error::missing_field("bar").to_string());
+    assert_eq!(
+        errs.next().unwrap().to_string(),
+        Error::duplicate_field("foo").to_string()
+    );
+    assert_eq!(
+        errs.next().unwrap().to_string(),
+        Error::missing_field("bar").to_string()
+    );
     assert!(errs.next().is_none());
 }
--- a/third_party/rust/darling/tests/supports.rs
+++ b/third_party/rust/darling/tests/supports.rs
@@ -1,45 +1,88 @@
 #[macro_use]
 extern crate darling;
 extern crate syn;
 
 use darling::ast;
 use darling::FromDeriveInput;
 
-#[derive(Debug,FromDeriveInput)]
+#[derive(Debug, FromDeriveInput)]
 #[darling(attributes(from_variants), supports(enum_any))]
 pub struct Container {
     data: ast::Data<Variant, ()>,
 }
 
 #[derive(Default, Debug, FromVariant)]
 #[darling(default, attributes(from_variants), supports(newtype, unit))]
 pub struct Variant {
     into: Option<bool>,
     skip: Option<bool>,
 }
 
-#[test]
-fn expansion() {
-    let di = syn::parse_str(r#"
+#[derive(Debug, FromDeriveInput)]
+#[darling(attributes(from_struct), supports(struct_named))]
+pub struct StructContainer {
+    data: ast::Data<(), syn::Field>,
+}
+
+mod source {
+    use syn::{self, DeriveInput};
+
+    pub fn newtype_enum() -> DeriveInput {
+        syn::parse_str(
+            r#"
         enum Hello {
             World(bool),
             String(String),
         }
-    "#).unwrap();
+    "#,
+        ).unwrap()
+    }
 
-    Container::from_derive_input(&di).unwrap();
-}
-
-#[test]
-fn unsupported_shape() {
-    let di = syn::parse_str(r#"
+    pub fn named_field_enum() -> DeriveInput {
+        syn::parse_str(
+            r#"
         enum Hello {
             Foo(u16),
             World {
                 name: String
             },
         }
-    "#).unwrap();
+    "#,
+        ).unwrap()
+    }
+
+    pub fn named_struct() -> DeriveInput {
+        syn::parse_str(
+            r#"
+        struct Hello {
+            world: bool,
+        }
+    "#,
+        ).unwrap()
+    }
+
+    pub fn tuple_struct() -> DeriveInput {
+        syn::parse_str("struct Hello(String, bool);").unwrap()
+    }
+}
 
-    Container::from_derive_input(&di).unwrap_err();
+#[test]
+fn enum_newtype_or_unit() {
+    // Should pass
+    Container::from_derive_input(&source::newtype_enum()).unwrap();
+
+    // Should error
+    Container::from_derive_input(&source::named_field_enum()).unwrap_err();
+    Container::from_derive_input(&source::named_struct()).unwrap_err();
 }
+
+#[test]
+fn struct_named() {
+    // Should pass
+    StructContainer::from_derive_input(&source::named_struct()).unwrap();
+
+    // Should fail
+    StructContainer::from_derive_input(&source::tuple_struct()).unwrap_err();
+    StructContainer::from_derive_input(&source::named_field_enum()).unwrap_err();
+    StructContainer::from_derive_input(&source::newtype_enum()).unwrap_err();
+}
--- 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":"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
+{"files":{"Cargo.toml":"f7061460abe53907c290c7975f49077a6c698e4acc9034d3e904c63a224dbd21","src/ast/data.rs":"c95e469d870f7918e77707da0e9e5e945e205e640bf34637355ef863b6efb28f","src/ast/generics.rs":"3bdfe1abdbee64f5aaa9b189dc5c58e222568f196ed206e9d6d91ea5f29673e7","src/ast/mod.rs":"58a58eeb1db7682e5994732cc8eb04088f6ca662805460ef443cf089e5c24e2c","src/codegen/attr_extractor.rs":"d13a3ba16f3a93f4a540421bb9df54a8f74cc6ee0e9e769b78b6c8045f285408","src/codegen/default_expr.rs":"60f23b77ddf80da70ec92fd0d8cb5a97143535df85eafa0e47943ac797ec46d2","src/codegen/error.rs":"50d0a1a2a392560ca10d3eb622ba745612761bf18846404742bd30caf2436228","src/codegen/field.rs":"d8b20dd1dda2c5591f5dcd4a2e5b8442ffae3daa23378323a81a682637080ea1","src/codegen/from_derive_impl.rs":"2a1e331d205db9334218b800760afcb64539fa2b25b0b2b014586b49b5b25882","src/codegen/from_field.rs":"af6f848ed7c6d2274e15d6307b011a1b8bcba66172ef68b0e665c9b4ae85157d","src/codegen/from_meta_impl.rs":"a937808b081e5d8bd16020fea8da0461e7e45872516cc0ee9e8a8cc957858a76","src/codegen/from_type_param.rs":"48493227f4a81fe1a533bd958b89207d56b1c70f754a2a28fb0e9eb9114a9aeb","src/codegen/from_variant_impl.rs":"3d9b10d60e3eb969946bbd210ce93a43375b9c8d3ffa827c7e87ab9235e2c3f3","src/codegen/mod.rs":"2dc3ee7f18177b2ef9c27c4f0cabc5bbd49f970abdba28a0539d81c70d81b6e2","src/codegen/outer_from_impl.rs":"059c3c05e4d6c7ba3876d23855ccbffa9e6158e7af7f6dc619b4d9770587f161","src/codegen/trait_impl.rs":"0e479f9e5b7253a3da2f77fd0bd63ea44a08a27dba2bd7dd992f05dc40b1d2a2","src/codegen/variant.rs":"3bc37ceb0e3dbf7eb02d7b66178adb3b165a24e92afa3295c012cf2f091d7328","src/codegen/variant_data.rs":"2467651663bfbb0ab35370b421d456948b053c26d0a23581a6c91ae7789b2db3","src/error.rs":"77436dc9a30172e94c434bdb61e3620ce37b2d64848a4fa19daba6e9c9329c95","src/from_derive_input.rs":"b2a04fefa4e14684061c819387ea0384297c67c7f50d5d0959aa69ab19075e76","src/from_field.rs":"f667924422ab4ab8d8b16ebfd42f61e74864cfaa80e96b49de5d1e1287e3d1d3","src/from_generic_param.rs":"49c5a8335eb0a9010998c5600c95c89440f7febe03265afb625d818dbc883d92","src/from_generics.rs":"7285b0fd213507e87c1da413cd1bc9eeada485d4a8f9d19630848d02a4d41c4a","src/from_meta.rs":"daa3d9a82b2f659147572f7d0e7fdef38139583e61e8319986098a4a73106453","src/from_type_param.rs":"9b611f276871002ade78146266fde3b6f9101b360082681a2fa2dafc16431f84","src/from_variant.rs":"70a23b5b4cb93c7e5a498fe9d16420b9b93bd69c1376d7703bc7cefd9417d159","src/lib.rs":"ea8f2d28793e4c0e367c4905e55e405417fbee9eb7ef0577f883b91aee1b5a57","src/macros_private.rs":"ef249cd9ca593aac423b4242df1c39c31610438da094c21562d74a7e5823c700","src/macros_public.rs":"3ed7eb99f309d9cd600d3a09ff4dcf5cc5d787fb49e8e5ead6bb00e31e5e6793","src/options/core.rs":"2dfb29a85a68d5ed6dccc46fe521c46ea8483bcd5d73cf21dbf21a7163ec318a","src/options/forward_attrs.rs":"89d8294a2204d6c32e5f58b797c23f4b035a8ff424bcf1b1c7db973ada89a4bc","src/options/from_derive.rs":"c8e41d2779e570dadd76c28b9cc9dd9cee57d8ef027766b4b5f39460a29df5d1","src/options/from_field.rs":"0b06590092a5c13d5c8eedf4e2d0518d869206813f828a06c65605d6cb8decc4","src/options/from_meta.rs":"ef268f78480f1d3df4e56cbc630aa4013ab5128cbb4471c4e85e9ff5a3980e7b","src/options/from_type_param.rs":"80d1fa60bac5bb31d0895e321faf1b8af99e407d9594028a01704b424be1dd4c","src/options/from_variant.rs":"99d4b60e48f8feef9c1fc2414ac0a420e66551c14e40c4a718668cca8e1f8cb5","src/options/input_field.rs":"08a5c584ccbb96ca11d2e58572ee654c269672f81cd76f9e2f29c3c23577c998","src/options/input_variant.rs":"29c39072f250dae92acf362185f81ea3ceac210e556f861e6cc0c87b043764dd","src/options/mod.rs":"30aefb531716954bad2b484c321baa333ef1d7d07ca55a0430df26bf4c1afb15","src/options/outer_from.rs":"e60196f2b9ea3ae014eaf3444607c6cf2a227c8d8aa4a5d64f59454602a0a5e6","src/options/shape.rs":"f6c110134954c62377e81d17e3fe623a9750ca7eb99eab853add114180f55904","src/usage/generics_ext.rs":"340774fe43033680e6b494c76dd4f558ada7ca4f09e91f9e4d076f125a729fc2","src/usage/ident_set.rs":"30edb2f0a599284967e3c6b579da31e5f9b15f3dd67bc9a82d6335eb44133df0","src/usage/lifetimes.rs":"19a63490660eb416bbccd4be9c060079a630dd15d5fd23c39e3c6c8c5498e369","src/usage/mod.rs":"bcf0ffb2257aed3b7b2cdad91c0136743384f39ff8f61f25c195c73b8fcdf144","src/usage/options.rs":"0491c995aad0d55783b24cce8a4e40f0f4435988c54ce2ded34763ac9b199fcf","src/usage/type_params.rs":"5aecf7f89c4b0623010e4717f5b32388b06d15e8511fde7b72f1d72e88fd3cb0","src/util/ident_list.rs":"fb6314436435547c111539213b209abd8d2593c28331560b84468a03b52d7c44","src/util/ident_string.rs":"06441e502d3bad342e292e42d083aff9070735a93d45f204aee5ef5f0144fdd0","src/util/ignored.rs":"7c979fbef880498ff64efda7396e759d80bf77fb1c7df0313bed8e533a16c0e0","src/util/mod.rs":"027793775e7079ea425f45b9bdad8b8fa309defcee02bf8ee6b6c556ec016342","src/util/over_ride.rs":"e90b3aeb41dd3364753f3ee6f8c6bbd85bf51d51569bf048396ec6e7735c569f","src/util/with_original.rs":"a545b38ba9d624fdc939eb844f001b7fc4102717b1d3683b4cbd0aae00fa7ef2"},"package":"86bc5ce438f4b703755d12f59bbf0a16c642766d4534e922db47569dbdd0b998"}
\ No newline at end of file
--- a/third_party/rust/darling_core/Cargo.toml
+++ b/third_party/rust/darling_core/Cargo.toml
@@ -7,28 +7,31 @@
 #
 # 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.4.0"
+version = "0.8.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.fnv]
+version = "1.0.6"
+
 [dependencies.ident_case]
 version = "1.0.0"
 
 [dependencies.proc-macro2]
-version = "0.3"
+version = "0.4.2"
 
 [dependencies.quote]
-version = "0.5"
+version = "0.6"
 
 [dependencies.syn]
-version = "0.13"
+version = "0.15"
 features = ["extra-traits"]
 
 [features]
 default = ["syn/full"]
deleted file mode 100644
--- a/third_party/rust/darling_core/src/ast.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-//! Utility types for working with the AST.
-
-use syn;
-
-use {Error, FromField, FromVariant, Result};
-
-/// A struct or enum body. 
-///
-/// `V` is the type which receives any encountered variants, and `F` receives struct fields.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Data<V, F> {
-    Enum(Vec<V>),
-    Struct(Fields<F>),
-}
-
-#[deprecated(since="0.3", note="this has been renamed to Data")]
-pub type Body<V, F> = Data<V, F>;
-
-impl<V, F> Data<V, F> {
-    /// Creates an empty body of the same shape as the passed-in body.
-    pub fn empty_from(src: &syn::Data) -> Self {
-        match *src {
-            syn::Data::Enum(_) => Data::Enum(vec![]),
-            syn::Data::Struct(ref vd) => Data::Struct(Fields::empty_from(&vd.fields)),
-            syn::Data::Union(_) => unreachable!(),
-        }
-    }
-
-    /// Creates a new `Data<&'a V, &'a F>` instance from `Data<V, F>`.
-    pub fn as_ref<'a>(&'a self) -> Data<&'a V, &'a F> {
-        match *self {
-            Data::Enum(ref variants) => Data::Enum(variants.into_iter().collect()),
-            Data::Struct(ref data) => Data::Struct(data.as_ref()),
-        }
-    }
-
-    /// Applies a function `V -> U` on enum variants, if this is an enum.
-    pub fn map_enum_variants<T, U>(self, map: T) -> Data<U, F>
-        where T: FnMut(V) -> U
-    {
-        match self {
-            Data::Enum(v) => Data::Enum(v.into_iter().map(map).collect()),
-            Data::Struct(f) => Data::Struct(f),
-        }
-    }
-
-    /// Applies a function `F -> U` on struct fields, if this is a struct.
-    pub fn map_struct_fields<T, U>(self, map: T) -> Data<V, U>
-        where T: FnMut(F) -> U
-    {
-        match self {
-            Data::Enum(v) => Data::Enum(v),
-            Data::Struct(f) => Data::Struct(f.map(map)),
-        }
-    }
-
-    /// Applies a function to the `Fields` if this is a struct.
-    pub fn map_struct<T, U>(self, mut map: T) -> Data<V, U>
-        where T: FnMut(Fields<F>) -> Fields<U>
-    {
-        match self {
-            Data::Enum(v) => Data::Enum(v),
-            Data::Struct(f) => Data::Struct(map(f)),
-        }
-    }
-
-    /// Consumes the `Data`, returning `Fields<F>` if it was a struct.
-    pub fn take_struct(self) -> Option<Fields<F>> {
-        match self {
-            Data::Enum(_) => None,
-            Data::Struct(f) => Some(f),
-        }
-    }
-
-    /// Consumes the `Data`, returning `Vec<V>` if it was an enum.
-    pub fn take_enum(self) -> Option<Vec<V>> {
-        match self {
-            Data::Enum(v) => Some(v),
-            Data::Struct(_) => None,
-        }
-    }
-
-    /// Returns `true` if this instance is `Data::Enum`.
-    pub fn is_enum(&self) -> bool {
-        match *self {
-            Data::Enum(_) => true,
-            Data::Struct(_) => false,
-        }
-    }
-
-    /// Returns `true` if this instance is `Data::Struct`.
-    pub fn is_struct(&self) -> bool {
-        !self.is_enum()
-    }
-}
-
-impl<V: FromVariant, F: FromField> Data<V, F> {
-    /// Attempt to convert from a `syn::Data` instance.
-    pub fn try_from(body: &syn::Data) -> Result<Self> {
-        match *body {
-            syn::Data::Enum(ref data) => {
-                let mut items = Vec::with_capacity(data.variants.len());
-                let mut errors = Vec::new();
-                for v_result in data.variants.clone().into_iter().map(|v| FromVariant::from_variant(&v)) {
-                    match v_result {
-                        Ok(val) => items.push(val),
-                        Err(err) => errors.push(err)
-                    }
-                }
-
-                if !errors.is_empty() {
-                    Err(Error::multiple(errors))
-                } else {
-                    Ok(Data::Enum(items))
-                }
-            }
-            syn::Data::Struct(ref data) => Ok(Data::Struct(Fields::try_from(&data.fields)?)),
-            syn::Data::Union(_) => unreachable!(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Fields<T> {
-    pub style: Style,
-    pub fields: Vec<T>,
-}
-
-#[deprecated(since="0.3", note="this has been renamed to Fields")]
-pub type VariantData<T> = Fields<T>;
-
-impl<T> Fields<T> {
-    pub fn empty_from(vd: &syn::Fields) -> Self {
-        Fields {
-            style: vd.into(),
-            fields: Vec::new(),
-        }
-    }
-
-    /// Splits the `Fields` into its style and fields for further processing.
-    /// Returns an empty `Vec` for `Unit` data.
-    pub fn split(self) -> (Style, Vec<T>) {
-        (self.style, self.fields)
-    }
-
-    /// Returns true if this variant's data makes it a newtype.
-    pub fn is_newtype(&self) -> bool {
-        self.style == Style::Tuple && self.fields.len() == 1
-    }
-
-    pub fn is_unit(&self) -> bool {
-        self.style.is_unit()
-    }
-
-    pub fn is_tuple(&self) -> bool {
-        self.style.is_tuple()
-    }
-
-    pub fn is_struct(&self) -> bool {
-        self.style.is_struct()
-    }
-
-    pub fn as_ref<'a>(&'a self) -> Fields<&'a T> {
-        Fields {
-            style: self.style,
-            fields: self.fields.iter().collect(),
-        }
-    }
-
-    pub fn map<F, U>(self, map: F) -> Fields<U> where F: FnMut(T) -> U {
-        Fields {
-            style: self.style,
-            fields: self.fields.into_iter().map(map).collect()
-        }
-    }
-}
-
-impl<F: FromField> Fields<F> {
-    pub fn try_from(fields: &syn::Fields) -> Result<Self> {
-        let (items, errors) = match *fields {
-            syn::Fields::Named(ref fields) => {
-                let mut items = Vec::with_capacity(fields.named.len());
-                let mut errors = Vec::new();
-
-                for field in &fields.named {
-                    let f_result = FromField::from_field(field);
-                    match f_result {
-                        Ok(val) => items.push(val),
-                        Err(err) => errors.push(if let Some(ref ident) = field.ident {
-                            err.at(ident.as_ref())
-                        } else {
-                            err
-                        })
-                    }
-                }
-
-                (items, errors)
-            }
-            syn::Fields::Unnamed(ref fields) => {
-                let mut items = Vec::with_capacity(fields.unnamed.len());
-                let mut errors = Vec::new();
-
-                for field in &fields.unnamed {
-                    let f_result = FromField::from_field(field);
-                    match f_result {
-                        Ok(val) => items.push(val),
-                        Err(err) => errors.push(if let Some(ref ident) = field.ident {
-                            err.at(ident.as_ref())
-                        } else {
-                            err
-                        })
-                    }
-                }
-
-                (items, errors)
-            }
-            syn::Fields::Unit => (vec![], vec![]),
-        };
-
-
-        if !errors.is_empty() {
-            Err(Error::multiple(errors))
-        } else {
-            Ok(Fields {
-                style: fields.into(),
-                fields: items,
-            })
-        }
-    }
-}
-
-impl<T> From<Style> for Fields<T> {
-    fn from(style: Style) -> Self {
-        Fields {
-            style,
-            fields: Vec::new(),
-        }
-    }
-}
-
-impl<T, U: Into<Vec<T>>> From<(Style, U)> for Fields<T> {
-    fn from((style, fields): (Style, U)) -> Self {
-        style.with_fields(fields)
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Style {
-    Tuple,
-    Struct,
-    Unit,
-}
-
-impl Style {
-    pub fn is_unit(&self) -> bool {
-        *self == Style::Unit
-    }
-
-    pub fn is_tuple(&self) -> bool {
-        *self == Style::Tuple
-    }
-
-    pub fn is_struct(&self) -> bool {
-        *self == Style::Struct
-    }
-
-    /// Creates a new `Fields` of the specified style with the passed-in fields.
-    fn with_fields<T, U: Into<Vec<T>>>(self, fields: U) -> Fields<T> {
-        Fields {
-            style: self,
-            fields: fields.into(),
-        }
-    }
-}
-
-impl From<syn::Fields> for Style {
-    fn from(vd: syn::Fields) -> Self {
-        (&vd).into()
-    }
-}
-
-impl<'a> From<&'a syn::Fields> for Style {
-    fn from(vd: &syn::Fields) -> Self {
-        match *vd {
-            syn::Fields::Named(_) => Style::Struct,
-            syn::Fields::Unnamed(_) => Style::Tuple,
-            syn::Fields::Unit => Style::Unit,
-        }
-    }
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/ast/data.rs
@@ -0,0 +1,352 @@
+use std::slice;
+
+use syn;
+
+use usage::{
+    self, IdentRefSet, IdentSet, LifetimeRefSet, LifetimeSet, UsesLifetimes, UsesTypeParams,
+};
+use {Error, FromField, FromVariant, Result};
+
+/// A struct or enum body.
+///
+/// `V` is the type which receives any encountered variants, and `F` receives struct fields.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Data<V, F> {
+    Enum(Vec<V>),
+    Struct(Fields<F>),
+}
+
+#[deprecated(since = "0.3", note = "this has been renamed to Data")]
+pub type Body<V, F> = Data<V, F>;
+
+impl<V, F> Data<V, F> {
+    /// Creates an empty body of the same shape as the passed-in body.
+    pub fn empty_from(src: &syn::Data) -> Self {
+        match *src {
+            syn::Data::Enum(_) => Data::Enum(vec![]),
+            syn::Data::Struct(ref vd) => Data::Struct(Fields::empty_from(&vd.fields)),
+            syn::Data::Union(_) => unreachable!(),
+        }
+    }
+
+    /// Creates a new `Data<&'a V, &'a F>` instance from `Data<V, F>`.
+    pub fn as_ref<'a>(&'a self) -> Data<&'a V, &'a F> {
+        match *self {
+            Data::Enum(ref variants) => Data::Enum(variants.into_iter().collect()),
+            Data::Struct(ref data) => Data::Struct(data.as_ref()),
+        }
+    }
+
+    /// Applies a function `V -> U` on enum variants, if this is an enum.
+    pub fn map_enum_variants<T, U>(self, map: T) -> Data<U, F>
+    where
+        T: FnMut(V) -> U,
+    {
+        match self {
+            Data::Enum(v) => Data::Enum(v.into_iter().map(map).collect()),
+            Data::Struct(f) => Data::Struct(f),
+        }
+    }
+
+    /// Applies a function `F -> U` on struct fields, if this is a struct.
+    pub fn map_struct_fields<T, U>(self, map: T) -> Data<V, U>
+    where
+        T: FnMut(F) -> U,
+    {
+        match self {
+            Data::Enum(v) => Data::Enum(v),
+            Data::Struct(f) => Data::Struct(f.map(map)),
+        }
+    }
+
+    /// Applies a function to the `Fields` if this is a struct.
+    pub fn map_struct<T, U>(self, mut map: T) -> Data<V, U>
+    where
+        T: FnMut(Fields<F>) -> Fields<U>,
+    {
+        match self {
+            Data::Enum(v) => Data::Enum(v),
+            Data::Struct(f) => Data::Struct(map(f)),
+        }
+    }
+
+    /// Consumes the `Data`, returning `Fields<F>` if it was a struct.
+    pub fn take_struct(self) -> Option<Fields<F>> {
+        match self {
+            Data::Enum(_) => None,
+            Data::Struct(f) => Some(f),
+        }
+    }
+
+    /// Consumes the `Data`, returning `Vec<V>` if it was an enum.
+    pub fn take_enum(self) -> Option<Vec<V>> {
+        match self {
+            Data::Enum(v) => Some(v),
+            Data::Struct(_) => None,
+        }
+    }
+
+    /// Returns `true` if this instance is `Data::Enum`.
+    pub fn is_enum(&self) -> bool {
+        match *self {
+            Data::Enum(_) => true,
+            Data::Struct(_) => false,
+        }
+    }
+
+    /// Returns `true` if this instance is `Data::Struct`.
+    pub fn is_struct(&self) -> bool {
+        !self.is_enum()
+    }
+}
+
+impl<V: FromVariant, F: FromField> Data<V, F> {
+    /// Attempt to convert from a `syn::Data` instance.
+    pub fn try_from(body: &syn::Data) -> Result<Self> {
+        match *body {
+            syn::Data::Enum(ref data) => {
+                let mut items = Vec::with_capacity(data.variants.len());
+                let mut errors = Vec::new();
+                for v_result in data.variants
+                    .clone()
+                    .into_iter()
+                    .map(|v| FromVariant::from_variant(&v))
+                {
+                    match v_result {
+                        Ok(val) => items.push(val),
+                        Err(err) => errors.push(err),
+                    }
+                }
+
+                if !errors.is_empty() {
+                    Err(Error::multiple(errors))
+                } else {
+                    Ok(Data::Enum(items))
+                }
+            }
+            syn::Data::Struct(ref data) => Ok(Data::Struct(Fields::try_from(&data.fields)?)),
+            syn::Data::Union(_) => unreachable!(),
+        }
+    }
+}
+
+impl<V: UsesTypeParams, F: UsesTypeParams> UsesTypeParams for Data<V, F> {
+    fn uses_type_params<'a>(
+        &self,
+        options: &usage::Options,
+        type_set: &'a IdentSet,
+    ) -> IdentRefSet<'a> {
+        match *self {
+            Data::Struct(ref v) => v.uses_type_params(options, type_set),
+            Data::Enum(ref v) => v.uses_type_params(options, type_set),
+        }
+    }
+}
+
+impl<V: UsesLifetimes, F: UsesLifetimes> UsesLifetimes for Data<V, F> {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &usage::Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            Data::Struct(ref v) => v.uses_lifetimes(options, lifetimes),
+            Data::Enum(ref v) => v.uses_lifetimes(options, lifetimes),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Fields<T> {
+    pub style: Style,
+    pub fields: Vec<T>,
+}
+
+#[deprecated(since = "0.3", note = "this has been renamed to Fields")]
+pub type VariantData<T> = Fields<T>;
+
+impl<T> Fields<T> {
+    pub fn empty_from(vd: &syn::Fields) -> Self {
+        Fields {
+            style: vd.into(),
+            fields: Vec::new(),
+        }
+    }
+
+    /// Splits the `Fields` into its style and fields for further processing.
+    /// Returns an empty `Vec` for `Unit` data.
+    pub fn split(self) -> (Style, Vec<T>) {
+        (self.style, self.fields)
+    }
+
+    /// Returns true if this variant's data makes it a newtype.
+    pub fn is_newtype(&self) -> bool {
+        self.style == Style::Tuple && self.fields.len() == 1
+    }
+
+    pub fn is_unit(&self) -> bool {
+        self.style.is_unit()
+    }
+
+    pub fn is_tuple(&self) -> bool {
+        self.style.is_tuple()
+    }
+
+    pub fn is_struct(&self) -> bool {
+        self.style.is_struct()
+    }
+
+    pub fn as_ref<'a>(&'a self) -> Fields<&'a T> {
+        Fields {
+            style: self.style,
+            fields: self.fields.iter().collect(),
+        }
+    }
+
+    pub fn map<F, U>(self, map: F) -> Fields<U>
+    where
+        F: FnMut(T) -> U,
+    {
+        Fields {
+            style: self.style,
+            fields: self.fields.into_iter().map(map).collect(),
+        }
+    }
+
+    pub fn iter(&self) -> slice::Iter<T> {
+        self.fields.iter()
+    }
+}
+
+impl<F: FromField> Fields<F> {
+    pub fn try_from(fields: &syn::Fields) -> Result<Self> {
+        let (items, errors) = match *fields {
+            syn::Fields::Named(ref fields) => {
+                let mut items = Vec::with_capacity(fields.named.len());
+                let mut errors = Vec::new();
+
+                for field in &fields.named {
+                    let f_result = FromField::from_field(field);
+                    match f_result {
+                        Ok(val) => items.push(val),
+                        Err(err) => errors.push(if let Some(ref ident) = field.ident {
+                            err.at(ident)
+                        } else {
+                            err
+                        }),
+                    }
+                }
+
+                (items, errors)
+            }
+            syn::Fields::Unnamed(ref fields) => {
+                let mut items = Vec::with_capacity(fields.unnamed.len());
+                let mut errors = Vec::new();
+
+                for field in &fields.unnamed {
+                    let f_result = FromField::from_field(field);
+                    match f_result {
+                        Ok(val) => items.push(val),
+                        Err(err) => errors.push(if let Some(ref ident) = field.ident {
+                            err.at(ident)
+                        } else {
+                            err
+                        }),
+                    }
+                }
+
+                (items, errors)
+            }
+            syn::Fields::Unit => (vec![], vec![]),
+        };
+
+        if !errors.is_empty() {
+            Err(Error::multiple(errors))
+        } else {
+            Ok(Fields {
+                style: fields.into(),
+                fields: items,
+            })
+        }
+    }
+}
+
+impl<T> From<Style> for Fields<T> {
+    fn from(style: Style) -> Self {
+        Fields {
+            style,
+            fields: Vec::new(),
+        }
+    }
+}
+
+impl<T, U: Into<Vec<T>>> From<(Style, U)> for Fields<T> {
+    fn from((style, fields): (Style, U)) -> Self {
+        style.with_fields(fields)
+    }
+}
+
+impl<T: UsesTypeParams> UsesTypeParams for Fields<T> {
+    fn uses_type_params<'a>(
+        &self,
+        options: &usage::Options,
+        type_set: &'a IdentSet,
+    ) -> IdentRefSet<'a> {
+        self.fields.uses_type_params(options, type_set)
+    }
+}
+
+impl<T: UsesLifetimes> UsesLifetimes for Fields<T> {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &usage::Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.fields.uses_lifetimes(options, lifetimes)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Style {
+    Tuple,
+    Struct,
+    Unit,
+}
+
+impl Style {
+    pub fn is_unit(&self) -> bool {
+        *self == Style::Unit
+    }
+
+    pub fn is_tuple(&self) -> bool {
+        *self == Style::Tuple
+    }
+
+    pub fn is_struct(&self) -> bool {
+        *self == Style::Struct
+    }
+
+    /// Creates a new `Fields` of the specified style with the passed-in fields.
+    fn with_fields<T, U: Into<Vec<T>>>(self, fields: U) -> Fields<T> {
+        Fields {
+            style: self,
+            fields: fields.into(),
+        }
+    }
+}
+
+impl From<syn::Fields> for Style {
+    fn from(vd: syn::Fields) -> Self {
+        (&vd).into()
+    }
+}
+
+impl<'a> From<&'a syn::Fields> for Style {
+    fn from(vd: &syn::Fields) -> Self {
+        match *vd {
+            syn::Fields::Named(_) => Style::Struct,
+            syn::Fields::Unnamed(_) => Style::Tuple,
+            syn::Fields::Unit => Style::Unit,
+        }
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/ast/generics.rs
@@ -0,0 +1,194 @@
+//! Types for working with generics
+
+use std::iter::Iterator;
+use std::slice::Iter;
+
+use syn;
+
+use {FromGenericParam, FromGenerics, FromTypeParam, Result};
+
+/// Extension trait for `GenericParam` to support getting values by variant.
+///
+/// # Usage
+/// `darling::ast::Generics` needs a way to test its params array in order to iterate over type params.
+/// Rather than require callers to use `darling::ast::GenericParam` in all cases, this trait makes that
+/// polymorphic.
+pub trait GenericParamExt {
+    /// The type this GenericParam uses to represent type params and their bounds
+    type TypeParam;
+    type LifetimeDef;
+    type ConstParam;
+
+    /// If this GenericParam is a type param, get the underlying value.
+    fn as_type_param(&self) -> Option<&Self::TypeParam> {
+        None
+    }
+
+    /// If this GenericParam is a lifetime, get the underlying value.
+    fn as_lifetime_def(&self) -> Option<&Self::LifetimeDef> {
+        None
+    }
+
+    /// If this GenericParam is a const param, get the underlying value.
+    fn as_const_param(&self) -> Option<&Self::ConstParam> {
+        None
+    }
+}
+
+impl GenericParamExt for syn::GenericParam {
+    type TypeParam = syn::TypeParam;
+    type LifetimeDef = syn::LifetimeDef;
+    type ConstParam = syn::ConstParam;
+
+    fn as_type_param(&self) -> Option<&Self::TypeParam> {
+        if let syn::GenericParam::Type(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+
+    fn as_lifetime_def(&self) -> Option<&Self::LifetimeDef> {
+        if let syn::GenericParam::Lifetime(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+
+    fn as_const_param(&self) -> Option<&Self::ConstParam> {
+        if let syn::GenericParam::Const(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+}
+
+impl GenericParamExt for syn::TypeParam {
+    type TypeParam = syn::TypeParam;
+    type LifetimeDef = ();
+    type ConstParam = ();
+
+    fn as_type_param(&self) -> Option<&Self::TypeParam> {
+        Some(self)
+    }
+}
+
+/// A mirror of `syn::GenericParam` which is generic over all its contents.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum GenericParam<T = syn::TypeParam, L = syn::LifetimeDef, C = syn::ConstParam> {
+    Type(T),
+    Lifetime(L),
+    Const(C),
+}
+
+impl<T: FromTypeParam> FromTypeParam for GenericParam<T> {
+    fn from_type_param(type_param: &syn::TypeParam) -> Result<Self> {
+        Ok(GenericParam::Type(FromTypeParam::from_type_param(
+            type_param,
+        )?))
+    }
+}
+
+impl<T: FromTypeParam> FromGenericParam for GenericParam<T> {
+    fn from_generic_param(param: &syn::GenericParam) -> Result<Self> {
+        Ok(match *param {
+            syn::GenericParam::Type(ref ty) => {
+                GenericParam::Type(FromTypeParam::from_type_param(ty)?)
+            }
+            syn::GenericParam::Lifetime(ref val) => GenericParam::Lifetime(val.clone()),
+            syn::GenericParam::Const(ref val) => GenericParam::Const(val.clone()),
+        })
+    }
+}
+
+impl<T, L, C> GenericParamExt for GenericParam<T, L, C> {
+    type TypeParam = T;
+    type LifetimeDef = L;
+    type ConstParam = C;
+
+    fn as_type_param(&self) -> Option<&T> {
+        if let GenericParam::Type(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+
+    fn as_lifetime_def(&self) -> Option<&L> {
+        if let GenericParam::Lifetime(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+
+    fn as_const_param(&self) -> Option<&C> {
+        if let GenericParam::Const(ref val) = *self {
+            Some(val)
+        } else {
+            None
+        }
+    }
+}
+
+/// A mirror of the `syn::Generics` type which can contain arbitrary representations
+/// of params and where clauses.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Generics<P, W = syn::WhereClause> {
+    pub params: Vec<P>,
+    pub where_clause: Option<W>,
+}
+
+impl<P, W> Generics<P, W> {
+    pub fn type_params<'a>(&'a self) -> TypeParams<'a, P> {
+        TypeParams(self.params.iter())
+    }
+}
+
+impl<P: FromGenericParam> FromGenerics for Generics<P> {
+    fn from_generics(generics: &syn::Generics) -> Result<Self> {
+        Ok(Generics {
+            params: generics
+                .params
+                .iter()
+                .map(FromGenericParam::from_generic_param)
+                .collect::<Result<Vec<P>>>()?,
+            where_clause: generics.where_clause.clone(),
+        })
+    }
+}
+
+pub struct TypeParams<'a, P: 'a>(Iter<'a, P>);
+
+impl<'a, P: GenericParamExt> Iterator for TypeParams<'a, P> {
+    type Item = &'a <P as GenericParamExt>::TypeParam;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let next = self.0.next();
+        match next {
+            None => None,
+            Some(v) => match v.as_type_param() {
+                Some(val) => Some(val),
+                None => self.next(),
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use syn;
+
+    use super::{GenericParam, Generics};
+    use FromGenerics;
+
+    #[test]
+    fn generics() {
+        let g: syn::Generics = parse_quote!(<T>);
+        let deified: Generics<GenericParam<syn::Ident>> = FromGenerics::from_generics(&g).unwrap();
+        assert!(deified.params.len() == 1);
+        assert!(deified.where_clause.is_none());
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/ast/mod.rs
@@ -0,0 +1,7 @@
+//! Utility types for working with the AST.
+
+mod data;
+mod generics;
+
+pub use self::data::*;
+pub use self::generics::{GenericParam, GenericParamExt, Generics};
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/codegen/attr_extractor.rs
@@ -0,0 +1,109 @@
+use proc_macro2::TokenStream;
+
+use options::ForwardAttrs;
+use util::IdentList;
+
+/// Infrastructure for generating an attribute extractor.
+pub trait ExtractAttribute {
+    /// A set of mutable declarations for all members of the implementing type.
+    fn local_declarations(&self) -> TokenStream;
+
+    /// A set of immutable declarations for all members of the implementing type.
+    /// This is used in the case where a deriving struct handles no attributes and therefore can
+    /// never change its default state.
+    fn immutable_declarations(&self) -> TokenStream;
+
+    /// Gets the list of attribute names that should be parsed by the extractor.
+    fn attr_names(&self) -> &IdentList;
+
+    fn forwarded_attrs(&self) -> Option<&ForwardAttrs>;
+
+    /// Gets the name used by the generated impl to return to the `syn` item passed as input.
+    fn param_name(&self) -> TokenStream;
+
+    /// Gets the core from-meta-item loop that should be used on matching attributes.
+    fn core_loop(&self) -> TokenStream;
+
+    fn declarations(&self) -> TokenStream {
+        if !self.attr_names().is_empty() {
+            self.local_declarations()
+        } else {
+            self.immutable_declarations()
+        }
+    }
+
+    /// Generates the main extraction loop.
+    fn extractor(&self) -> TokenStream {
+        let declarations = self.declarations();
+
+        let will_parse_any = !self.attr_names().is_empty();
+        let will_fwd_any = self.forwarded_attrs()
+            .map(|fa| !fa.is_empty())
+            .unwrap_or_default();
+
+        if !(will_parse_any || will_fwd_any) {
+            return quote! {
+                #declarations
+            };
+        }
+
+        let input = self.param_name();
+
+        // The block for parsing attributes whose names have been claimed by the target
+        // struct. If no attributes were claimed, this is a pass-through.
+        let parse_handled = if will_parse_any {
+            let attr_names = self.attr_names().to_strings();
+            let core_loop = self.core_loop();
+            quote!(
+                #(#attr_names)|* => {
+                    if let Some(::syn::Meta::List(ref __data)) = __attr.interpret_meta() {
+                        let __items = &__data.nested;
+
+                        #core_loop
+                    } else {
+                        // darling currently only supports list-style
+                        continue
+                    }
+                }
+            )
+        } else {
+            quote!()
+        };
+
+        // Specifies the behavior for unhandled attributes. They will either be silently ignored or
+        // forwarded to the inner struct for later analysis.
+        let forward_unhandled = if will_fwd_any {
+            forwards_to_local(self.forwarded_attrs().unwrap())
+        } else {
+            quote!(_ => continue)
+        };
+
+        quote!(
+            #declarations
+            use ::darling::ToTokens;
+            let mut __fwd_attrs: ::darling::export::Vec<::syn::Attribute> = vec![];
+
+            for __attr in &#input.attrs {
+                // Filter attributes based on name
+                match  ::darling::export::ToString::to_string(&__attr.path.clone().into_token_stream()).as_str() {
+                    #parse_handled
+                    #forward_unhandled
+                }
+            }
+        )
+    }
+}
+
+fn forwards_to_local(behavior: &ForwardAttrs) -> TokenStream {
+    let push_command = quote!(__fwd_attrs.push(__attr.clone()));
+    match *behavior {
+        ForwardAttrs::All => quote!(_ => #push_command),
+        ForwardAttrs::Only(ref idents) => {
+            let names = idents.to_strings();
+            quote!(
+                #(#names)|* => #push_command,
+                _ => continue,
+            )
+        }
+    }
+}
\ No newline at end of file
--- a/third_party/rust/darling_core/src/codegen/default_expr.rs
+++ b/third_party/rust/darling_core/src/codegen/default_expr.rs
@@ -1,9 +1,10 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
 use syn::{Ident, Path};
 
 /// This will be in scope during struct initialization after option parsing.
 const DEFAULT_STRUCT_NAME: &str = "__default";
 
 /// The fallback value for a field or container.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefaultExpression<'a> {
@@ -16,30 +17,30 @@ pub enum DefaultExpression<'a> {
 
 impl<'a> DefaultExpression<'a> {
     pub fn as_declaration(&'a self) -> DefaultDeclaration<'a> {
         DefaultDeclaration(self)
     }
 }
 
 impl<'a> ToTokens for DefaultExpression<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         tokens.append_all(match *self {
             DefaultExpression::Inherit(ident) => {
                 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) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         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/error.rs
+++ b/third_party/rust/darling_core/src/codegen/error.rs
@@ -1,55 +1,54 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
 
 /// Declares the local variable into which errors will be accumulated.
 pub struct ErrorDeclaration {
-    __hidden: ()
+    __hidden: (),
 }
 
 impl ErrorDeclaration {
     pub fn new() -> Self {
-        ErrorDeclaration {
-            __hidden: ()
-        }
+        ErrorDeclaration { __hidden: () }
     }
 }
 
 impl ToTokens for ErrorDeclaration {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         tokens.append_all(quote! {
             let mut __errors = Vec::new();
         })
     }
 }
 
 /// Returns early if attribute or body parsing has caused any errors.
 pub struct ErrorCheck<'a> {
     location: Option<&'a str>,
-    __hidden: ()
+    __hidden: (),
 }
 
 impl<'a> ErrorCheck<'a> {
     pub fn new() -> Self {
         ErrorCheck {
             location: None,
-            __hidden: ()
+            __hidden: (),
         }
     }
 
     pub fn with_location(location: &'a str) -> Self {
         ErrorCheck {
             location: Some(location),
             __hidden: (),
         }
     }
 }
 
 impl<'a> ToTokens for ErrorCheck<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let at_call = if let Some(ref s) = self.location {
             quote!(.at(#s))
         } else {
             quote!()
         };
 
         tokens.append_all(quote! {
             if !__errors.is_empty() {
--- a/third_party/rust/darling_core/src/codegen/field.rs
+++ b/third_party/rust/darling_core/src/codegen/field.rs
@@ -1,20 +1,22 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
 use syn::{Ident, Path, Type};
 
 use codegen::DefaultExpression;
+use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 
 /// Properties needed to generate code for a field in all the contexts
 /// where one may appear.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Field<'a> {
     /// The name presented to the user of the library. This will appear
     /// in error messages and will be looked when parsing names.
-    pub name_in_attr: &'a str,
+    pub name_in_attr: String,
 
     /// The name presented to the author of the library. This will appear
     /// in the setters or temporary variables which contain the values.
     pub ident: &'a Ident,
 
     /// The type of the field in the input.
     pub ty: &'a Type,
     pub default_expression: Option<DefaultExpression<'a>>,
@@ -37,28 +39,38 @@ impl<'a> Field<'a> {
         Initializer(self)
     }
 
     pub fn as_presence_check(&'a self) -> CheckMissing<'a> {
         CheckMissing(self)
     }
 }
 
+impl<'a> UsesTypeParams for Field<'a> {
+    fn uses_type_params<'b>(
+        &self,
+        options: &usage::Options,
+        type_set: &'b IdentSet,
+    ) -> IdentRefSet<'b> {
+        self.ty.uses_type_params(options, type_set)
+    }
+}
+
 /// An individual field during variable declaration in the generated parsing method.
 pub struct Declaration<'a>(&'a Field<'a>, bool);
 
 impl<'a> Declaration<'a> {
     /// Creates a new declaration with the given field and mutability.
     pub fn new(field: &'a Field<'a>, mutable: bool) -> Self {
         Declaration(field, mutable)
     }
 }
 
 impl<'a> ToTokens for Declaration<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let field: &Field = self.0;
         let ident = field.ident;
         let ty = field.ty;
 
         let mutable = if self.1 { quote!(mut) } else { quote!() };
 
         tokens.append_all(if field.multiple {
             // This is NOT mutable, as it will be declared mutable only temporarily.
@@ -68,20 +80,20 @@ impl<'a> ToTokens for Declaration<'a> {
         });
     }
 }
 
 /// Represents an individual field in the match.
 pub struct MatchArm<'a>(&'a Field<'a>);
 
 impl<'a> ToTokens for MatchArm<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let field: &Field = self.0;
         if !field.skip {
-            let name_str = field.name_in_attr;
+            let name_str = &field.name_in_attr;
             let ident = field.ident;
             let with_path = &field.with_path;
 
             // Errors include the location of the bad input, so we compute that here.
             // Fields that take multiple values add the index of the error for convenience,
             // while single-value fields only expose the name in the input attribute.
             let location = if field.multiple {
                 // we use the local variable `len` here because location is accessed via
@@ -135,17 +147,17 @@ impl<'a> ToTokens for MatchArm<'a> {
         }
     }
 }
 
 /// Wrapper to generate initialization code for a field.
 pub struct Initializer<'a>(&'a Field<'a>);
 
 impl<'a> ToTokens for Initializer<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let field: &Field = self.0;
         let ident = field.ident;
         tokens.append_all(if field.multiple {
             if let Some(ref expr) = field.default_expression {
                 quote!(#ident: if !#ident.is_empty() {
                     #ident
                 } else {
                     #expr
@@ -165,20 +177,20 @@ impl<'a> ToTokens for Initializer<'a> {
         });
     }
 }
 
 /// Creates an error if a field has no value and no default.
 pub struct CheckMissing<'a>(&'a Field<'a>);
 
 impl<'a> ToTokens for CheckMissing<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         if !self.0.multiple && self.0.default_expression.is_none() {
             let ident = self.0.ident;
-            let name_in_attr = self.0.name_in_attr;
+            let name_in_attr = &self.0.name_in_attr;
 
             tokens.append_all(quote! {
                 if !#ident.0 {
                     __errors.push(::darling::Error::missing_field(#name_in_attr));
                 }
             })
         }
     }
deleted file mode 100644
--- a/third_party/rust/darling_core/src/codegen/fmi_impl.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use quote::{Tokens, ToTokens};
-use syn;
-
-use ast::{Data, Style, Fields};
-use codegen::{Field, TraitImpl, OuterFromImpl, Variant};
-
-pub struct FmiImpl<'a> {
-    pub base: TraitImpl<'a>,
-}
-
-impl<'a> ToTokens for FmiImpl<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
-        let base = &self.base;
-
-        let impl_block = match base.data {
-            // Unit structs allow empty bodies only.
-            Data::Struct(ref vd) if vd.style.is_unit() => {
-                let ty_ident = base.ident;
-                quote!(
-                    fn from_word() -> ::darling::Result<Self> {
-                        Ok(#ty_ident)
-                    }
-                )
-            }
-
-            // Newtype structs proxy to the sole value they contain.
-            Data::Struct(Fields { ref fields, style: Style::Tuple, .. }) if fields.len() == 1 => {
-                let ty_ident = base.ident;
-                quote!(
-                    fn from_meta_item(__item: &::syn::Meta) -> ::darling::Result<Self> {
-                        Ok(#ty_ident(::darling::FromMetaItem::from_meta_item(__item)?))
-                    }
-                )
-            }
-            Data::Struct(Fields { style: Style::Tuple, .. }) => {
-                panic!("Multi-field tuples are not supported");
-            }
-            Data::Struct(ref data) => {
-                let inits = data.fields.iter().map(Field::as_initializer);
-                let declare_errors = base.declare_errors();
-                let require_fields = base.require_fields();
-                let check_errors = base.check_errors();
-                let decls = base.local_declarations();
-                let core_loop = base.core_loop();
-                let default = base.fallback_decl();
-                let map = base.map_fn();
-
-
-                quote!(
-                    fn from_list(__items: &[::syn::NestedMeta]) -> ::darling::Result<Self> {
-
-                        #decls
-
-                        #declare_errors
-
-                        #core_loop
-
-                        #require_fields
-
-                        #check_errors
-
-                        #default
-
-                        ::darling::export::Ok(Self {
-                            #(#inits),*
-                        }) #map
-                    }
-                )
-            }
-            Data::Enum(ref variants) => {
-                let unit_arms = variants.iter().map(Variant::as_unit_match_arm);
-                let struct_arms = variants.iter().map(Variant::as_data_match_arm);
-
-                quote!(
-                    fn from_list(__outer: &[::syn::NestedMeta]) -> ::darling::Result<Self> {
-                        // An enum must have exactly one value inside the parentheses if it's not a unit
-                        // match arm
-                        match __outer.len() {
-                            0 => ::darling::export::Err(::darling::Error::too_few_items(1)),
-                            1 => {
-                                if let ::syn::NestedMeta::Meta(ref __nested) = __outer[0] {
-                                    match __nested.name().as_ref() {
-                                        #(#struct_arms)*
-                                        __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
-                                    }
-                                } else {
-                                    ::darling::export::Err(::darling::Error::unsupported_format("literal"))
-                                }
-                            }
-                            _ => ::darling::export::Err(::darling::Error::too_many_items(1)),
-                        }
-                    }
-
-                    fn from_string(lit: &str) -> ::darling::Result<Self> {
-                        match lit {
-                            #(#unit_arms)*
-                            __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
-                        }
-                    }
-                )
-            }
-        };
-
-        self.wrap(impl_block, tokens);
-    }
-}
-
-impl<'a> OuterFromImpl<'a> for FmiImpl<'a> {
-    fn trait_path(&self) -> syn::Path {
-        path!(::darling::FromMetaItem)
-    }
-
-    fn base(&'a self) -> &'a TraitImpl<'a> {
-        &self.base
-    }
-}
--- a/third_party/rust/darling_core/src/codegen/from_derive_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/from_derive_impl.rs
@@ -1,130 +1,146 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
 use ast::Data;
-use codegen::{TraitImpl, ExtractAttribute, OuterFromImpl};
+use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
 use options::{ForwardAttrs, Shape};
+use util::IdentList;
 
 pub struct FromDeriveInputImpl<'a> {
     pub ident: Option<&'a Ident>,
     pub generics: Option<&'a Ident>,
     pub vis: Option<&'a Ident>,
     pub attrs: Option<&'a Ident>,
     pub data: Option<&'a Ident>,
     pub base: TraitImpl<'a>,
-    pub attr_names: Vec<&'a str>,
+    pub attr_names: &'a IdentList,
     pub forward_attrs: Option<&'a ForwardAttrs>,
-    pub from_ident: Option<bool>,
+    pub from_ident: bool,
     pub supports: Option<&'a Shape>,
 }
 
 impl<'a> ToTokens for FromDeriveInputImpl<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let ty_ident = self.base.ident;
         let input = self.param_name();
         let map = self.base.map_fn();
 
         if let Data::Struct(ref data) = self.base.data {
             if data.is_newtype() {
-                self.wrap(quote!{
-                    fn from_derive_input(#input: &::syn::DeriveInput) -> ::darling::Result<Self> {
-                        ::darling::export::Ok(
-                            #ty_ident(::darling::FromDeriveInput::from_derive_input(#input)?)
-                        ) #map
-                    }
-                }, tokens);
+                self.wrap(
+                    quote!{
+                        fn from_derive_input(#input: &::syn::DeriveInput) -> ::darling::Result<Self> {
+                            ::darling::export::Ok(
+                                #ty_ident(::darling::FromDeriveInput::from_derive_input(#input)?)
+                            ) #map
+                        }
+                    },
+                    tokens,
+                );
 
                 return;
             }
         }
 
-        let passed_ident = self.ident.as_ref().map(|i| quote!(#i: #input.ident.clone(),));
+        let passed_ident = self.ident
+            .as_ref()
+            .map(|i| quote!(#i: #input.ident.clone(),));
         let passed_vis = self.vis.as_ref().map(|i| quote!(#i: #input.vis.clone(),));
-        let passed_generics = self.generics.as_ref().map(|i| quote!(#i: #input.generics.clone(),));
+        let passed_generics = self.generics
+            .as_ref()
+            .map(|i| quote!(#i: ::darling::FromGenerics::from_generics(&#input.generics)?,));
         let passed_attrs = self.attrs.as_ref().map(|i| quote!(#i: __fwd_attrs,));
-        let passed_body = self.data.as_ref().map(|i| quote!(#i: ::darling::ast::Data::try_from(&#input.data)?,));
+        let passed_body = self.data
+            .as_ref()
+            .map(|i| quote!(#i: ::darling::ast::Data::try_from(&#input.data)?,));
 
-        let supports = self.supports.map(|i| quote!{
-            #i
-            __validate_body(&#input.data)?;
+        let supports = self.supports.map(|i| {
+            quote!{
+                #i
+                __validate_body(&#input.data)?;
+            }
         });
 
         let inits = self.base.initializers();
-        let default = if let Some(true) = self.from_ident {
+        let default = if self.from_ident {
             quote!(let __default: Self = ::darling::export::From::from(#input.ident.clone());)
         } else {
             self.base.fallback_decl()
         };
 
         let grab_attrs = self.extractor();
 
         let declare_errors = self.base.declare_errors();
         let require_fields = self.base.require_fields();
         let check_errors = self.base.check_errors();
 
-        self.wrap(quote! {
-            fn from_derive_input(#input: &::syn::DeriveInput) -> ::darling::Result<Self> {
-                #declare_errors
-
-                #grab_attrs
+        self.wrap(
+            quote! {
+                fn from_derive_input(#input: &::syn::DeriveInput) -> ::darling::Result<Self> {
+                    #declare_errors
 
-                #supports
+                    #grab_attrs
+
+                    #supports
 
-                #require_fields
+                    #require_fields
 
-                #check_errors
+                    #check_errors
 
-                #default
+                    #default
 
-                ::darling::export::Ok(#ty_ident {
-                    #passed_ident
-                    #passed_generics
-                    #passed_vis
-                    #passed_attrs
-                    #passed_body
-                    #inits
-                }) #map
-            }
-        }, tokens);
+                    ::darling::export::Ok(#ty_ident {
+                        #passed_ident
+                        #passed_generics
+                        #passed_vis
+                        #passed_attrs
+                        #passed_body
+                        #inits
+                    }) #map
+                }
+            },
+            tokens,
+        );
     }
 }
 
 impl<'a> ExtractAttribute for FromDeriveInputImpl<'a> {
-    fn attr_names(&self) -> &[&str] {
-        self.attr_names.as_slice()
+    fn attr_names(&self) -> &IdentList {
+        &self.attr_names
     }
 
     fn forwarded_attrs(&self) -> Option<&ForwardAttrs> {
         self.forward_attrs
     }
 
-    fn param_name(&self) -> Tokens {
+    fn param_name(&self) -> TokenStream {
         quote!(__di)
     }
 
-    fn core_loop(&self) -> Tokens {
+    fn core_loop(&self) -> TokenStream {
         self.base.core_loop()
     }
 
-    fn local_declarations(&self) -> Tokens {
+    fn local_declarations(&self) -> TokenStream {
         self.base.local_declarations()
     }
 
-    fn immutable_declarations(&self) -> Tokens {
+    fn immutable_declarations(&self) -> TokenStream {
         self.base.immutable_declarations()
     }
 }
 
 impl<'a> OuterFromImpl<'a> for FromDeriveInputImpl<'a> {
     fn trait_path(&self) -> syn::Path {
         path!(::darling::FromDeriveInput)
     }
 
     fn trait_bound(&self) -> syn::Path {
-        path!(::darling::FromMetaItem)
+        path!(::darling::FromMeta)
     }
 
     fn base(&'a self) -> &'a TraitImpl<'a> {
         &self.base
     }
 }
--- a/third_party/rust/darling_core/src/codegen/from_field.rs
+++ b/third_party/rust/darling_core/src/codegen/from_field.rs
@@ -1,108 +1,115 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
-use codegen::{TraitImpl, ExtractAttribute, OuterFromImpl};
+use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
 use options::ForwardAttrs;
+use util::IdentList;
 
 /// `impl FromField` generator. This is used for parsing an individual
 /// field and its attributes.
 pub struct FromFieldImpl<'a> {
     pub ident: Option<&'a Ident>,
     pub vis: Option<&'a Ident>,
     pub ty: Option<&'a Ident>,
     pub attrs: Option<&'a Ident>,
     pub base: TraitImpl<'a>,
-    pub attr_names: Vec<&'a str>,
+    pub attr_names: &'a IdentList,
     pub forward_attrs: Option<&'a ForwardAttrs>,
     pub from_ident: bool,
 }
 
 impl<'a> ToTokens for FromFieldImpl<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let input = self.param_name();
 
         let error_declaration = self.base.declare_errors();
         let require_fields = self.base.require_fields();
         let error_check = self.base.check_errors();
 
         let initializers = self.base.initializers();
 
         let default = if self.from_ident {
             quote!(let __default: Self = ::darling::export::From::from(#input.ident.clone());)
         } else {
             self.base.fallback_decl()
         };
 
-        let passed_ident = self.ident.as_ref().map(|i| quote!(#i: #input.ident.clone(),));
+        let passed_ident = self.ident
+            .as_ref()
+            .map(|i| quote!(#i: #input.ident.clone(),));
         let passed_vis = self.vis.as_ref().map(|i| quote!(#i: #input.vis.clone(),));
         let passed_ty = self.ty.as_ref().map(|i| quote!(#i: #input.ty.clone(),));
         let passed_attrs = self.attrs.as_ref().map(|i| quote!(#i: __fwd_attrs,));
 
         // Determine which attributes to forward (if any).
         let grab_attrs = self.extractor();
         let map = self.base.map_fn();
 
-        self.wrap(quote!{
-            fn from_field(#input: &::syn::Field) -> ::darling::Result<Self> {
-                #error_declaration
+        self.wrap(
+            quote!{
+                fn from_field(#input: &::syn::Field) -> ::darling::Result<Self> {
+                    #error_declaration
 
-                #grab_attrs
+                    #grab_attrs
+
+                    #require_fields
 
-                #require_fields
+                    #error_check
 
-                #error_check
+                    #default
 
-                #default
+                    ::darling::export::Ok(Self {
+                        #passed_ident
+                        #passed_ty
+                        #passed_vis
+                        #passed_attrs
+                        #initializers
+                    }) #map
 
-                ::darling::export::Ok(Self {
-                    #passed_ident
-                    #passed_ty
-                    #passed_vis
-                    #passed_attrs
-                    #initializers
-                }) #map
-
-            }
-        }, tokens);
+                }
+            },
+            tokens,
+        );
     }
 }
 
 impl<'a> ExtractAttribute for FromFieldImpl<'a> {
-    fn attr_names(&self) -> &[&str] {
-        self.attr_names.as_slice()
+    fn attr_names(&self) -> &IdentList {
+        &self.attr_names
     }
 
     fn forwarded_attrs(&self) -> Option<&ForwardAttrs> {
         self.forward_attrs
     }
 
-    fn param_name(&self) -> Tokens {
+    fn param_name(&self) -> TokenStream {
         quote!(__field)
     }
 
-    fn core_loop(&self) -> Tokens {
+    fn core_loop(&self) -> TokenStream {
         self.base.core_loop()
     }
 
-    fn local_declarations(&self) -> Tokens {
+    fn local_declarations(&self) -> TokenStream {
         self.base.local_declarations()
     }
 
-    fn immutable_declarations(&self) -> Tokens {
+    fn immutable_declarations(&self) -> TokenStream {
         self.base.immutable_declarations()
     }
 }
 
 impl<'a> OuterFromImpl<'a> for FromFieldImpl<'a> {
     fn trait_path(&self) -> syn::Path {
         path!(::darling::FromField)
     }
 
     fn trait_bound(&self) -> syn::Path {
-        path!(::darling::FromMetaItem)
+        path!(::darling::FromMeta)
     }
 
     fn base(&'a self) -> &'a TraitImpl<'a> {
         &self.base
     }
-}
\ No newline at end of file
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/codegen/from_meta_impl.rs
@@ -0,0 +1,124 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn;
+
+use ast::{Data, Fields, Style};
+use codegen::{Field, OuterFromImpl, TraitImpl, Variant};
+
+pub struct FromMetaImpl<'a> {
+    pub base: TraitImpl<'a>,
+}
+
+impl<'a> ToTokens for FromMetaImpl<'a> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let base = &self.base;
+
+        let impl_block = match base.data {
+            // Unit structs allow empty bodies only.
+            Data::Struct(ref vd) if vd.style.is_unit() => {
+                let ty_ident = base.ident;
+                quote!(
+                    fn from_word() -> ::darling::Result<Self> {
+                        Ok(#ty_ident)
+                    }
+                )
+            }
+
+            // Newtype structs proxy to the sole value they contain.
+            Data::Struct(Fields {
+                ref fields,
+                style: Style::Tuple,
+                ..
+            }) if fields.len() == 1 =>
+            {
+                let ty_ident = base.ident;
+                quote!(
+                    fn from_meta(__item: &::syn::Meta) -> ::darling::Result<Self> {
+                        Ok(#ty_ident(::darling::FromMeta::from_meta(__item)?))
+                    }
+                )
+            }
+            Data::Struct(Fields {
+                style: Style::Tuple,
+                ..
+            }) => {
+                panic!("Multi-field tuples are not supported");
+            }
+            Data::Struct(ref data) => {
+                let inits = data.fields.iter().map(Field::as_initializer);
+                let declare_errors = base.declare_errors();
+                let require_fields = base.require_fields();
+                let check_errors = base.check_errors();
+                let decls = base.local_declarations();
+                let core_loop = base.core_loop();
+                let default = base.fallback_decl();
+                let map = base.map_fn();
+
+                quote!(
+                    fn from_list(__items: &[::syn::NestedMeta]) -> ::darling::Result<Self> {
+
+                        #decls
+
+                        #declare_errors
+
+                        #core_loop
+
+                        #require_fields
+
+                        #check_errors
+
+                        #default
+
+                        ::darling::export::Ok(Self {
+                            #(#inits),*
+                        }) #map
+                    }
+                )
+            }
+            Data::Enum(ref variants) => {
+                let unit_arms = variants.iter().map(Variant::as_unit_match_arm);
+                let struct_arms = variants.iter().map(Variant::as_data_match_arm);
+
+                quote!(
+                    fn from_list(__outer: &[::syn::NestedMeta]) -> ::darling::Result<Self> {
+                        // An enum must have exactly one value inside the parentheses if it's not a unit
+                        // match arm
+                        match __outer.len() {
+                            0 => ::darling::export::Err(::darling::Error::too_few_items(1)),
+                            1 => {
+                                if let ::syn::NestedMeta::Meta(ref __nested) = __outer[0] {
+                                    match __nested.name().to_string().as_ref() {
+                                        #(#struct_arms)*
+                                        __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
+                                    }
+                                } else {
+                                    ::darling::export::Err(::darling::Error::unsupported_format("literal"))
+                                }
+                            }
+                            _ => ::darling::export::Err(::darling::Error::too_many_items(1)),
+                        }
+                    }
+
+                    fn from_string(lit: &str) -> ::darling::Result<Self> {
+                        match lit {
+                            #(#unit_arms)*
+                            __other => ::darling::export::Err(::darling::Error::unknown_value(__other))
+                        }
+                    }
+                )
+            }
+        };
+
+        self.wrap(impl_block, tokens);
+    }
+}
+
+impl<'a> OuterFromImpl<'a> for FromMetaImpl<'a> {
+    fn trait_path(&self) -> syn::Path {
+        path!(::darling::FromMeta)
+    }
+
+    fn base(&'a self) -> &'a TraitImpl<'a> {
+        &self.base
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/codegen/from_type_param.rs
@@ -0,0 +1,114 @@
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::{self, Ident};
+
+use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
+use options::ForwardAttrs;
+use util::IdentList;
+
+pub struct FromTypeParamImpl<'a> {
+    pub base: TraitImpl<'a>,
+    pub ident: Option<&'a Ident>,
+    pub attrs: Option<&'a Ident>,
+    pub bounds: Option<&'a Ident>,
+    pub default: Option<&'a Ident>,
+    pub attr_names: &'a IdentList,
+    pub forward_attrs: Option<&'a ForwardAttrs>,
+    pub from_ident: bool,
+}
+
+impl<'a> ToTokens for FromTypeParamImpl<'a> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let input = self.param_name();
+
+        let error_declaration = self.base.declare_errors();
+        let grab_attrs = self.extractor();
+        let require_fields = self.base.require_fields();
+        let error_check = self.base.check_errors();
+
+        let default = if self.from_ident {
+            quote!(let __default: Self = ::darling::export::From::from(#input.ident.clone());)
+        } else {
+            self.base.fallback_decl()
+        };
+
+        let passed_ident = self.ident
+            .as_ref()
+            .map(|i| quote!(#i: #input.ident.clone(),));
+        let passed_attrs = self.attrs.as_ref().map(|i| quote!(#i: __fwd_attrs,));
+        let passed_bounds = self.bounds
+            .as_ref()
+            .map(|i| quote!(#i: #input.bounds.clone().into_iter().collect::<Vec<_>>(),));
+        let passed_default = self.default
+            .as_ref()
+            .map(|i| quote!(#i: #input.default.clone(),));
+        let initializers = self.base.initializers();
+
+        let map = self.base.map_fn();
+
+        self.wrap(
+            quote! {
+                fn from_type_param(#input: &::syn::TypeParam) -> ::darling::Result<Self> {
+                    #error_declaration
+
+                    #grab_attrs
+
+                    #require_fields
+
+                    #error_check
+
+                    #default
+
+                    ::darling::export::Ok(Self {
+                        #passed_ident
+                        #passed_bounds
+                        #passed_default
+                        #passed_attrs
+                        #initializers
+                    }) #map
+                }
+            },
+            tokens,
+        );
+    }
+}
+
+impl<'a> ExtractAttribute for FromTypeParamImpl<'a> {
+    fn attr_names(&self) -> &IdentList {
+        &self.attr_names
+    }
+
+    fn forwarded_attrs(&self) -> Option<&ForwardAttrs> {
+        self.forward_attrs
+    }
+
+    fn param_name(&self) -> TokenStream {
+        quote!(__type_param)
+    }
+
+    fn core_loop(&self) -> TokenStream {
+        self.base.core_loop()
+    }
+
+    fn local_declarations(&self) -> TokenStream {
+        self.base.local_declarations()
+    }
+
+    fn immutable_declarations(&self) -> TokenStream {
+        self.base.immutable_declarations()
+    }
+}
+
+impl<'a> OuterFromImpl<'a> for FromTypeParamImpl<'a> {
+    fn trait_path(&self) -> syn::Path {
+        path!(::darling::FromTypeParam)
+    }
+
+    fn trait_bound(&self) -> syn::Path {
+        path!(::darling::FromMeta)
+    }
+
+    fn base(&'a self) -> &'a TraitImpl<'a> {
+        &self.base
+    }
+}
--- a/third_party/rust/darling_core/src/codegen/from_variant_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/from_variant_impl.rs
@@ -1,52 +1,61 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::ToTokens;
 use syn::{self, Ident};
 
 use codegen::{ExtractAttribute, OuterFromImpl, TraitImpl};
 use options::{DataShape, ForwardAttrs};
+use util::IdentList;
 
 pub struct FromVariantImpl<'a> {
     pub base: TraitImpl<'a>,
     pub ident: Option<&'a Ident>,
     pub fields: Option<&'a Ident>,
     pub attrs: Option<&'a Ident>,
-    pub attr_names: Vec<&'a str>,
+    pub attr_names: &'a IdentList,
     pub forward_attrs: Option<&'a ForwardAttrs>,
-    pub from_ident: Option<bool>,
+    pub from_ident: bool,
     pub supports: Option<&'a DataShape>,
 }
 
 impl<'a> ToTokens for FromVariantImpl<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let input = self.param_name();
         let extractor = self.extractor();
-        let passed_ident = self.ident.as_ref().map(|i| quote!(#i: #input.ident.clone(),));
+        let passed_ident = self.ident
+            .as_ref()
+            .map(|i| quote!(#i: #input.ident.clone(),));
         let passed_attrs = self.attrs.as_ref().map(|i| quote!(#i: __fwd_attrs,));
-        let passed_fields = self.fields.as_ref().map(|i| quote!(#i: ::darling::ast::Fields::try_from(&#input.fields)?,));
+        let passed_fields = self.fields
+            .as_ref()
+            .map(|i| quote!(#i: ::darling::ast::Fields::try_from(&#input.fields)?,));
 
         let inits = self.base.initializers();
         let map = self.base.map_fn();
 
-        let default = if let Some(true) = self.from_ident {
+        let default = if self.from_ident {
             quote!(let __default: Self = ::darling::export::From::from(#input.ident.clone());)
         } else {
             self.base.fallback_decl()
         };
 
-        let supports = self.supports.map(|i| quote! {
-            #i
-            __validate_data(&#input.fields)?;
+        let supports = self.supports.map(|i| {
+            quote! {
+                #i
+                __validate_data(&#input.fields)?;
+            }
         });
 
         let error_declaration = self.base.declare_errors();
         let require_fields = self.base.require_fields();
         let error_check = self.base.check_errors();
 
-        self.wrap(quote!(
+        self.wrap(
+            quote!(
             fn from_variant(#input: &::syn::Variant) -> ::darling::Result<Self> {
                 #error_declaration
 
                 #extractor
 
                 #supports
 
                 #require_fields
@@ -57,52 +66,53 @@ impl<'a> ToTokens for FromVariantImpl<'a
 
                 ::darling::export::Ok(Self {
                     #passed_ident
                     #passed_attrs
                     #passed_fields
                     #inits
                 }) #map
             }
-        ), tokens);
+        ),
+            tokens,
+        );
     }
 }
 
 impl<'a> ExtractAttribute for FromVariantImpl<'a> {
-    fn local_declarations(&self) -> Tokens {
+    fn local_declarations(&self) -> TokenStream {
         self.base.local_declarations()
     }
 
-    fn immutable_declarations(&self) -> Tokens {
+    fn immutable_declarations(&self) -> TokenStream {
         self.base.immutable_declarations()
     }
 
-    fn attr_names(&self) -> &[&str] {
-        self.attr_names.as_slice()
+    fn attr_names(&self) -> &IdentList {
+        &self.attr_names
     }
 
     fn forwarded_attrs(&self) -> Option<&ForwardAttrs> {
         self.forward_attrs
     }
 
-    fn param_name(&self) -> Tokens {
+    fn param_name(&self) -> TokenStream {
         quote!(__variant)
     }
 
-    fn core_loop(&self) -> Tokens {
+    fn core_loop(&self) -> TokenStream {
         self.base.core_loop()
     }
 }
 
-
 impl<'a> OuterFromImpl<'a> for FromVariantImpl<'a> {
     fn trait_path(&self) -> syn::Path {
         path!(::darling::FromVariant)
     }
 
     fn trait_bound(&self) -> syn::Path {
-        path!(::darling::FromMetaItem)
+        path!(::darling::FromMeta)
     }
 
     fn base(&'a self) -> &'a TraitImpl<'a> {
         &self.base
     }
 }
--- a/third_party/rust/darling_core/src/codegen/mod.rs
+++ b/third_party/rust/darling_core/src/codegen/mod.rs
@@ -1,124 +1,29 @@
-use quote::Tokens;
 
+mod attr_extractor;
 mod default_expr;
 mod error;
 mod field;
-mod fmi_impl;
+mod from_meta_impl;
 mod from_derive_impl;
 mod from_field;
+mod from_type_param;
 mod from_variant_impl;
 mod outer_from_impl;
 mod trait_impl;
 mod variant;
 mod variant_data;
 
+pub(in codegen) use self::attr_extractor::ExtractAttribute;
 pub use self::default_expr::DefaultExpression;
 pub use self::field::Field;
-pub use self::fmi_impl::FmiImpl;
+pub use self::from_meta_impl::FromMetaImpl;
 pub use self::from_derive_impl::FromDeriveInputImpl;
 pub use self::from_field::FromFieldImpl;
+pub use self::from_type_param::FromTypeParamImpl;
 pub use self::from_variant_impl::FromVariantImpl;
 pub use self::outer_from_impl::OuterFromImpl;
 pub use self::trait_impl::TraitImpl;
 pub use self::variant::Variant;
 pub use self::variant_data::FieldsGen;
 
-use options::ForwardAttrs;
 
-/// Infrastructure for generating an attribute extractor.
-pub trait ExtractAttribute {
-    fn local_declarations(&self) -> Tokens;
-
-    fn immutable_declarations(&self) -> Tokens;
-
-    /// Gets the list of attribute names that should be parsed by the extractor.
-    fn attr_names(&self) -> &[&str];
-
-    fn forwarded_attrs(&self) -> Option<&ForwardAttrs>;
-
-    /// Gets the name used by the generated impl to return to the `syn` item passed as input.
-    fn param_name(&self) -> Tokens;
-
-    /// Gets the core from-meta-item loop that should be used on matching attributes.
-    fn core_loop(&self) -> Tokens;
-
-    fn declarations(&self) -> Tokens {
-        if !self.attr_names().is_empty() {
-            self.local_declarations()
-        } else {
-            self.immutable_declarations()
-        }
-    }
-
-    /// Generates the main extraction loop.
-    fn extractor(&self) -> Tokens {
-        let declarations = self.declarations();
-
-        let will_parse_any = !self.attr_names().is_empty();
-        let will_fwd_any = self.forwarded_attrs().map(|fa| !fa.is_empty()).unwrap_or_default();
-
-        if !(will_parse_any || will_fwd_any) {
-            return quote! {
-                #declarations
-            };
-        }
-
-        let input = self.param_name();
-
-        // The block for parsing attributes whose names have been claimed by the target
-        // struct. If no attributes were claimed, this is a pass-through.
-        let parse_handled = if will_parse_any {
-            let attr_names = self.attr_names();
-            let core_loop = self.core_loop();
-            quote!(
-                #(#attr_names)|* => {
-                    if let Some(::syn::Meta::List(ref __data)) = __attr.interpret_meta() {
-                        let __items = &__data.nested;
-
-                        #core_loop
-                    } else {
-                        // darling currently only supports list-style
-                        continue
-                    }
-                }
-            )
-        } else {
-            quote!()
-        };
-
-        // Specifies the behavior for unhandled attributes. They will either be silently ignored or
-        // forwarded to the inner struct for later analysis.
-        let forward_unhandled = if will_fwd_any {
-            forwards_to_local(self.forwarded_attrs().unwrap())
-        } else {
-            quote!(_ => continue)
-        };
-
-        quote!(
-            #declarations
-            let mut __fwd_attrs: ::darling::export::Vec<::syn::Attribute> = vec![];
-
-            for __attr in &#input.attrs {
-                // Filter attributes based on name
-                match __attr.path.segments.iter().map(|s| s.ident.as_ref()).collect::<Vec<&str>>().join("::").as_str() {
-                    #parse_handled
-                    #forward_unhandled
-                }
-            }
-        )
-    }
-}
-
-fn forwards_to_local(behavior: &ForwardAttrs) -> Tokens {
-    let push_command = quote!(__fwd_attrs.push(__attr.clone()));
-    match *behavior {
-        ForwardAttrs::All => quote!(_ => #push_command),
-        ForwardAttrs::Only(ref idents) => {
-            let names = idents.as_strs();
-            quote!(
-                #(#names)|* => #push_command,
-                _ => continue,
-            )
-        }
-    }
-}
--- a/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/outer_from_impl.rs
@@ -1,53 +1,60 @@
-use syn::{Generics, Path, TraitBound, TraitBoundModifier, TypeParamBound, GenericParam};
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
+use syn::{GenericParam, Generics, Path, TraitBound, TraitBoundModifier, TypeParamBound};
 
 use codegen::TraitImpl;
+use usage::IdentSet;
 
 /// Wrapper for "outer From" traits, such as `FromDeriveInput`, `FromVariant`, and `FromField`.
 pub trait OuterFromImpl<'a> {
     /// Gets the path of the trait being implemented.
     fn trait_path(&self) -> Path;
 
     fn base(&'a self) -> &'a TraitImpl<'a>;
 
     fn trait_bound(&self) -> Path {
         self.trait_path()
     }
 
-    fn wrap<T: ToTokens>(&'a self, body: T, tokens: &mut Tokens) {
+    fn wrap<T: ToTokens>(&'a self, body: T, tokens: &mut TokenStream) {
         let base = self.base();
         let trayt = self.trait_path();
         let ty_ident = base.ident;
-        let generics = compute_impl_bounds(self.trait_bound(), base.generics.clone());
+        // The type parameters used in non-skipped, non-magic fields.
+        // These must impl `FromMeta` unless they have custom bounds.
+        let used = base.used_type_params();
+        let generics = compute_impl_bounds(self.trait_bound(), base.generics.clone(), &used);
         let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
         tokens.append_all(quote!(
             impl #impl_generics #trayt for #ty_ident #ty_generics
                 #where_clause
             {
                 #body
             }
         ));
     }
 }
 
-fn compute_impl_bounds(bound: Path, mut generics: Generics) -> Generics {
+fn compute_impl_bounds(bound: Path, mut generics: Generics, applies_to: &IdentSet) -> Generics {
     if generics.params.is_empty() {
         return generics;
     }
 
     let added_bound = TypeParamBound::Trait(TraitBound {
-            paren_token: None,
-            modifier: TraitBoundModifier::None,
-            lifetimes: None,
-            path: bound,
-        });
+        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());
+            if applies_to.contains(&typ.ident) {
+                typ.bounds.push(added_bound.clone());
+            }
         }
     }
 
     generics
 }
--- a/third_party/rust/darling_core/src/codegen/trait_impl.rs
+++ b/third_party/rust/darling_core/src/codegen/trait_impl.rs
@@ -1,94 +1,149 @@
-use quote::Tokens;
+use proc_macro2::TokenStream;
 use syn::{Generics, Ident, Path, WherePredicate};
 
-use codegen::{DefaultExpression, Field, Variant, FieldsGen};
+use ast::{Data, Fields};
+use codegen::error::{ErrorCheck, ErrorDeclaration};
 use codegen::field;
-use codegen::error::{ErrorCheck, ErrorDeclaration};
-use ast::Data;
+use codegen::{DefaultExpression, Field, FieldsGen, Variant};
+use usage::{CollectTypeParams, IdentSet, Purpose};
 
 #[derive(Debug)]
 pub struct TraitImpl<'a> {
     pub ident: &'a Ident,
     pub generics: &'a Generics,
     pub data: Data<Variant<'a>, Field<'a>>,
     pub default: Option<DefaultExpression<'a>>,
     pub map: Option<&'a Path>,
     pub bound: Option<&'a [WherePredicate]>,
 }
 
 impl<'a> TraitImpl<'a> {
+    /// Get all declared type parameters.
+    pub fn declared_type_params(&self) -> IdentSet {
+        self.generics
+            .type_params()
+            .map(|tp| tp.ident.clone())
+            .collect()
+    }
+
+    /// Get the type parameters which are used by non-skipped fields.
+    pub fn used_type_params(&self) -> IdentSet {
+        self.type_params_matching(|f| !f.skip, |v| !v.skip)
+    }
+
+    /// Get the type parameters which are used by skipped fields.
+    pub fn skipped_type_params(&self) -> IdentSet {
+        self.type_params_matching(|f| f.skip, |v| v.skip)
+    }
+
+    fn type_params_matching<'b, F, V>(&'b self, field_filter: F, variant_filter: V) -> IdentSet
+    where
+        F: Fn(&&Field) -> bool,
+        V: Fn(&&Variant) -> bool,
+    {
+        let declared = self.declared_type_params();
+        match self.data {
+            Data::Struct(ref v) => self.type_params_in_fields(v, &field_filter, &declared),
+            Data::Enum(ref v) => v.iter().filter(variant_filter).fold(
+                Default::default(),
+                |mut state, variant| {
+                    state.extend(self.type_params_in_fields(
+                        &variant.data,
+                        &field_filter,
+                        &declared,
+                    ));
+                    state
+                },
+            ),
+        }
+    }
+
+    /// Get the type parameters of all fields in a set matching some filter
+    fn type_params_in_fields<'b, F>(
+        &'b self,
+        fields: &'b Fields<Field<'a>>,
+        field_filter: F,
+        declared: &IdentSet,
+    ) -> IdentSet
+    where
+        F: Fn(&&'b Field) -> bool,
+    {
+        fields
+            .iter()
+            .filter(field_filter)
+            .collect_type_params_cloned(&Purpose::BoundImpl.into(), declared)
+    }
+}
+
+impl<'a> TraitImpl<'a> {
     /// Gets the `let` declaration for errors accumulated during parsing.
     pub fn declare_errors(&self) -> ErrorDeclaration {
         ErrorDeclaration::new()
     }
 
     /// Gets the check which performs an early return if errors occurred during parsing.
     pub fn check_errors(&self) -> ErrorCheck {
         ErrorCheck::new()
     }
 
     /// Generate local variable declarations for all fields.
-    pub(in codegen) fn local_declarations(&self) -> Tokens {
+    pub(in codegen) fn local_declarations(&self) -> TokenStream {
         if let Data::Struct(ref vd) = self.data {
             let vdr = vd.as_ref().map(Field::as_declaration);
             let decls = vdr.fields.as_slice();
             quote!(#(#decls)*)
         } else {
             quote!()
         }
     }
 
     /// Generate immutable variable declarations for all fields.
-    pub(in codegen) fn immutable_declarations(&self) -> Tokens {
+    pub(in codegen) fn immutable_declarations(&self) -> TokenStream {
         if let Data::Struct(ref vd) = self.data {
             let vdr = vd.as_ref().map(|f| field::Declaration::new(f, false));
             let decls = vdr.fields.as_slice();
             quote!(#(#decls)*)
         } else {
             quote!()
         }
     }
 
-    pub(in codegen) fn map_fn(&self) -> Option<Tokens> {
+    pub(in codegen) fn map_fn(&self) -> Option<TokenStream> {
         self.map.as_ref().map(|path| quote!(.map(#path)))
     }
 
     /// Generate local variable declaration and initialization for instance from which missing fields will be taken.
-    pub(in codegen) fn fallback_decl(&self) -> Tokens {
+    pub(in codegen) fn fallback_decl(&self) -> TokenStream {
         let default = self.default.as_ref().map(DefaultExpression::as_declaration);
         quote!(#default)
     }
 
-    pub fn require_fields(&self) -> Tokens {
+    pub fn require_fields(&self) -> TokenStream {
         if let Data::Struct(ref vd) = self.data {
             let check_nones = vd.as_ref().map(Field::as_presence_check);
             let checks = check_nones.fields.as_slice();
             quote!(#(#checks)*)
         } else {
             quote!()
         }
     }
 
-    pub(in codegen) fn initializers(&self) -> Tokens {
+    pub(in codegen) fn initializers(&self) -> TokenStream {
         let foo = match self.data {
             Data::Enum(_) => panic!("Core loop on enums isn't supported"),
-            Data::Struct(ref data) => {
-                FieldsGen(data)
-            }
+            Data::Struct(ref data) => FieldsGen(data),
         };
 
         foo.initializers()
     }
 
     /// Generate the loop which walks meta items looking for property matches.
-    pub(in codegen) fn core_loop(&self) -> Tokens {
+    pub(in codegen) fn core_loop(&self) -> TokenStream {
         let foo = match self.data {
             Data::Enum(_) => panic!("Core loop on enums isn't supported"),
-            Data::Struct(ref data) => {
-                FieldsGen(data)
-            }
+            Data::Struct(ref data) => FieldsGen(data),
         };
 
         foo.core_loop()
     }
 }
--- a/third_party/rust/darling_core/src/codegen/variant.rs
+++ b/third_party/rust/darling_core/src/codegen/variant.rs
@@ -1,20 +1,22 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
 use syn::Ident;
 
 use ast::Fields;
+use codegen::error::{ErrorCheck, ErrorDeclaration};
 use codegen::{Field, FieldsGen};
-use codegen::error::{ErrorCheck, ErrorDeclaration};
+use usage::{self, IdentRefSet, IdentSet, UsesTypeParams};
 
 /// An enum variant.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Variant<'a> {
-    /// The name which will appear in code passed to the `FromMetaItem` input.
-    pub name_in_attr: &'a str,
+    /// The name which will appear in code passed to the `FromMeta` input.
+    pub name_in_attr: String,
 
     /// The name of the variant which will be returned for a given `name_in_attr`.
     pub variant_ident: &'a Ident,
 
     /// The name of the parent enum type.
     pub ty_ident: &'a Ident,
 
     pub data: Fields<Field<'a>>,
@@ -28,27 +30,37 @@ impl<'a> Variant<'a> {
         UnitMatchArm(self)
     }
 
     pub fn as_data_match_arm(&'a self) -> DataMatchArm<'a> {
         DataMatchArm(self)
     }
 }
 
+impl<'a> UsesTypeParams for Variant<'a> {
+    fn uses_type_params<'b>(
+        &self,
+        options: &usage::Options,
+        type_set: &'b IdentSet,
+    ) -> IdentRefSet<'b> {
+        self.data.uses_type_params(options, type_set)
+    }
+}
+
 pub struct UnitMatchArm<'a>(&'a Variant<'a>);
 
 impl<'a> ToTokens for UnitMatchArm<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let val: &Variant<'a> = self.0;
 
         if val.skip {
             return;
         }
 
-        let name_in_attr = val.name_in_attr;
+        let name_in_attr = &val.name_in_attr;
 
         if val.data.is_unit() {
             let variant_ident = val.variant_ident;
             let ty_ident = val.ty_ident;
 
             tokens.append_all(quote!(
                 #name_in_attr => ::darling::export::Ok(#ty_ident::#variant_ident),
             ));
@@ -58,41 +70,40 @@ impl<'a> ToTokens for UnitMatchArm<'a> {
             ));
         }
     }
 }
 
 pub struct DataMatchArm<'a>(&'a Variant<'a>);
 
 impl<'a> ToTokens for DataMatchArm<'a> {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let val: &Variant<'a> = self.0;
 
         if val.skip {
             return;
         }
 
-        let name_in_attr = val.name_in_attr;
+        let name_in_attr = &val.name_in_attr;
         let variant_ident = val.variant_ident;
         let ty_ident = val.ty_ident;
 
         if val.data.is_unit() {
             tokens.append_all(quote!(
                 #name_in_attr => ::darling::export::Err(::darling::Error::unsupported_format("list")),
             ));
 
             return;
         }
 
-
         let vdg = FieldsGen(&val.data);
 
         if val.data.is_struct() {
             let declare_errors = ErrorDeclaration::new();
-            let check_errors = ErrorCheck::with_location(name_in_attr);
+            let check_errors = ErrorCheck::with_location(&name_in_attr);
             let require_fields = vdg.require_fields();
             let decls = vdg.declarations();
             let core_loop = vdg.core_loop();
             let inits = vdg.initializers();
 
             tokens.append_all(quote!(
                 #name_in_attr => {
                     if let ::syn::Meta::List(ref __data) = *__nested {
@@ -116,17 +127,17 @@ impl<'a> ToTokens for DataMatchArm<'a> {
                     }
                 }
             ));
         } else if val.data.is_newtype() {
             tokens.append_all(quote!(
                 #name_in_attr => {
                     ::darling::export::Ok(
                         #ty_ident::#variant_ident(
-                            ::darling::FromMetaItem::from_meta_item(__nested)
+                            ::darling::FromMeta::from_meta(__nested)
                                 .map_err(|e| e.at(#name_in_attr))?)
                     )
                 }
             ));
         } else {
             panic!("Match arms aren't supported for tuple variants yet");
         }
     }
--- a/third_party/rust/darling_core/src/codegen/variant_data.rs
+++ b/third_party/rust/darling_core/src/codegen/variant_data.rs
@@ -1,53 +1,59 @@
-use quote::Tokens;
+use proc_macro2::TokenStream;
 
+use ast::Fields;
 use ast::Style;
 use codegen::field;
 use codegen::Field;
-use ast::Fields;
 
 pub struct FieldsGen<'a>(pub &'a Fields<Field<'a>>);
 
 impl<'a> FieldsGen<'a> {
-    pub(in codegen) fn declarations(&self) -> Tokens {
+    pub(in codegen) fn declarations(&self) -> TokenStream {
         match *self.0 {
-            Fields { style: Style::Struct, ref fields } => {
+            Fields {
+                style: Style::Struct,
+                ref fields,
+            } => {
                 let vdr = fields.into_iter().map(Field::as_declaration);
                 quote!(#(#vdr)*)
             }
             _ => panic!("FieldsGen doesn't support tuples yet"),
         }
     }
 
     /// Generate the loop which walks meta items looking for property matches.
-    pub(in codegen) fn core_loop(&self) -> Tokens {
+    pub(in codegen) fn core_loop(&self) -> TokenStream {
         let arms: Vec<field::MatchArm> = self.0.as_ref().map(Field::as_match).fields;
 
         quote!(
             for __item in __items {
                 if let ::syn::NestedMeta::Meta(ref __inner) = *__item {
                     let __name = __inner.name().to_string();
                     match __name.as_str() {
                         #(#arms)*
                         __other => { __errors.push(::darling::Error::unknown_field(__other)); }
                     }
                 }
             }
         )
     }
 
-    pub fn require_fields(&self) -> Tokens {
+    pub fn require_fields(&self) -> TokenStream {
         match *self.0 {
-            Fields { style: Style::Struct, ref fields } => {
+            Fields {
+                style: Style::Struct,
+                ref fields,
+            } => {
                 let checks = fields.into_iter().map(Field::as_presence_check);
                 quote!(#(#checks)*)
             }
-            _ => panic!("FieldsGen doesn't support tuples for requirement checks")
+            _ => panic!("FieldsGen doesn't support tuples for requirement checks"),
         }
     }
 
-    pub(in codegen) fn initializers(&self) -> Tokens {
+    pub(in codegen) fn initializers(&self) -> TokenStream {
         let inits: Vec<_> = self.0.as_ref().map(Field::as_initializer).fields;
 
         quote!(#(#inits),*)
     }
 }
--- a/third_party/rust/darling_core/src/error.rs
+++ b/third_party/rust/darling_core/src/error.rs
@@ -46,16 +46,21 @@ impl Error {
     }
 
     /// Creates a new error for a field name that appears in the input but does not correspond
     /// to a known field.
     pub fn unknown_field(name: &str) -> Self {
         Error::new(ErrorKind::UnknownField(name.into()))
     }
 
+    /// Creates a new error for a struct or variant that does not adhere to the supported shape.
+    pub fn unsupported_shape(shape: &str) -> Self {
+        Error::new(ErrorKind::UnsupportedShape(shape.into()))
+    }
+
     pub fn unsupported_format(format: &str) -> Self {
         Error::new(ErrorKind::UnexpectedFormat(format.into()))
     }
 
     /// Creates a new error for a field which has an unexpected literal type.
     pub fn unexpected_type(ty: &str) -> Self {
         Error::new(ErrorKind::UnexpectedType(ty.into()))
     }
@@ -79,17 +84,19 @@ impl Error {
     /// Bundle a set of multiple errors into a single `Error` instance.
     ///
     /// # Panics
     /// This function will panic if `errors.is_empty() == true`.
     pub fn multiple(mut errors: Vec<Error>) -> Self {
         if errors.len() > 1 {
             Error::new(ErrorKind::Multiple(errors))
         } else if errors.len() == 1 {
-            errors.pop().expect("Error array of length 1 has a first item")
+            errors
+                .pop()
+                .expect("Error array of length 1 has a first item")
         } else {
             panic!("Can't deal with 0 errors")
         }
     }
 
     /// Recursively converts a tree of errors to a flattened list.
     pub fn flatten(self) -> Self {
         Error::multiple(self.to_vec())
@@ -163,21 +170,21 @@ impl fmt::Display for Error {
 
 impl IntoIterator for Error {
     type Item = Error;
     type IntoIter = IntoIter;
 
     fn into_iter(self) -> IntoIter {
         if let ErrorKind::Multiple(errors) = self.kind {
             IntoIter {
-                inner: IntoIterEnum::Multiple(errors.into_iter())
+                inner: IntoIterEnum::Multiple(errors.into_iter()),
             }
         } else {
             IntoIter {
-                inner: IntoIterEnum::Single(iter::once(self))
+                inner: IntoIterEnum::Single(iter::once(self)),
             }
         }
     }
 }
 
 enum IntoIterEnum {
     Single(iter::Once<Error>),
     Multiple(vec::IntoIter<Error>),
@@ -191,62 +198,65 @@ impl Iterator for IntoIterEnum {
             IntoIterEnum::Single(ref mut content) => content.next(),
             IntoIterEnum::Multiple(ref mut content) => content.next(),
         }
     }
 }
 
 /// An iterator that moves out of an `Error`.
 pub struct IntoIter {
-    inner: IntoIterEnum
+    inner: IntoIterEnum,
 }
 
 impl Iterator for IntoIter {
     type Item = Error;
 
     fn next(&mut self) -> Option<Error> {
         self.inner.next()
     }
 }
 
+type DeriveInputShape = String;
 type FieldName = String;
 type MetaFormat = String;
 
 #[derive(Debug)]
 // Don't want to publicly commit to ErrorKind supporting equality yet, but
 // not having it makes testing very difficult.
 #[cfg_attr(test, derive(Clone, PartialEq, Eq))]
 enum ErrorKind {
     /// An arbitrary error message.
     Custom(String),
     DuplicateField(FieldName),
     MissingField(FieldName),
+    UnsupportedShape(DeriveInputShape),
     UnknownField(FieldName),
     UnexpectedFormat(MetaFormat),
     UnexpectedType(String),
     UnknownValue(String),
     TooFewItems(usize),
     TooManyItems(usize),
     /// A set of errors.
     Multiple(Vec<Error>),
 
     // TODO make this variant take `!` so it can't exist
     #[doc(hidden)]
-    __NonExhaustive
+    __NonExhaustive,
 }
 
 impl ErrorKind {
     pub fn description(&self) -> &str {
         use self::ErrorKind::*;
 
         match *self {
             Custom(ref s) => s,
             DuplicateField(_) => "Duplicate field",
             MissingField(_) => "Missing field",
             UnknownField(_) => "Unexpected field",
+            UnsupportedShape(_) => "Unsupported shape",
             UnexpectedFormat(_) => "Unexpected meta-item format",
             UnexpectedType(_) => "Unexpected literal type",
             UnknownValue(_) => "Unknown literal value",
             TooFewItems(_) => "Too few items",
             TooManyItems(_) => "Too many items",
             Multiple(_) => "Multiple errors",
             __NonExhaustive => unreachable!(),
         }
@@ -266,16 +276,17 @@ impl fmt::Display for ErrorKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use self::ErrorKind::*;
 
         match *self {
             Custom(ref s) => s.fmt(f),
             DuplicateField(ref field) => write!(f, "Duplicate field `{}`", field),
             MissingField(ref field) => write!(f, "Missing field `{}`", field),
             UnknownField(ref field) => write!(f, "Unexpected field `{}`", field),
+            UnsupportedShape(ref shape) => write!(f, "Unsupported shape `{}`", shape),
             UnexpectedFormat(ref format) => write!(f, "Unexpected meta-item format `{}`", format),
             UnexpectedType(ref ty) => write!(f, "Unexpected literal type `{}`", ty),
             UnknownValue(ref val) => write!(f, "Unknown literal value `{}`", val),
             TooFewItems(ref min) => write!(f, "Too few items: Expected at least {}", min),
             TooManyItems(ref max) => write!(f, "Too many items: Expected no more than {}", max),
             Multiple(ref items) if items.len() == 1 => items[0].fmt(f),
             Multiple(ref items) => {
                 write!(f, "Multiple errors: (")?;
@@ -286,17 +297,17 @@ impl fmt::Display for ErrorKind {
                     } else {
                         first = false;
                     }
 
                     item.fmt(f)?;
                 }
 
                 write!(f, ")")
-            },
+            }
             __NonExhaustive => unreachable!(),
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::Error;
@@ -306,18 +317,19 @@ mod tests {
         let err = Error::duplicate_field("hello").at("world");
         assert_eq!(err.clone().flatten(), err);
     }
 
     #[test]
     fn flatten_simple() {
         let err = Error::multiple(vec![
             Error::unknown_field("hello").at("world"),
-            Error::missing_field("hell_no").at("world")
-        ]).at("foo").flatten();
+            Error::missing_field("hell_no").at("world"),
+        ]).at("foo")
+            .flatten();
 
         assert!(err.location().is_empty());
 
         let mut err_iter = err.into_iter();
 
         let first = err_iter.next();
         assert!(first.is_some());
         assert_eq!(first.unwrap().location(), vec!["foo", "world"]);
@@ -335,29 +347,27 @@ mod tests {
         let err = Error::duplicate_field("hello");
         assert_eq!(1, err.len());
     }
 
     #[test]
     fn len_multiple() {
         let err = Error::multiple(vec![
             Error::duplicate_field("hello"),
-            Error::missing_field("hell_no")
+            Error::missing_field("hell_no"),
         ]);
         assert_eq!(2, err.len());
     }
 
     #[test]
     fn len_nested() {
         let err = Error::multiple(vec![
             Error::duplicate_field("hello"),
             Error::multiple(vec![
                 Error::duplicate_field("hi"),
                 Error::missing_field("bye"),
-                Error::multiple(vec![
-                    Error::duplicate_field("whatsup")
-                ])
-            ])
+                Error::multiple(vec![Error::duplicate_field("whatsup")]),
+            ]),
         ]);
 
         assert_eq!(4, err.len());
     }
 }
--- a/third_party/rust/darling_core/src/from_derive_input.rs
+++ b/third_party/rust/darling_core/src/from_derive_input.rs
@@ -18,9 +18,9 @@ impl FromDeriveInput for () {
         Ok(())
     }
 }
 
 impl FromDeriveInput for DeriveInput {
     fn from_derive_input(input: &DeriveInput) -> Result<Self> {
         Ok(input.clone())
     }
-}
\ No newline at end of file
+}
--- a/third_party/rust/darling_core/src/from_field.rs
+++ b/third_party/rust/darling_core/src/from_field.rs
@@ -30,9 +30,9 @@ impl FromField for syn::Visibility {
         Ok(field.vis.clone())
     }
 }
 
 impl FromField for Vec<syn::Attribute> {
     fn from_field(field: &Field) -> Result<Self> {
         Ok(field.attrs.clone())
     }
-}
\ No newline at end of file
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/from_generic_param.rs
@@ -0,0 +1,21 @@
+use syn;
+
+use Result;
+
+/// Creates an instance by parsing a specific `syn::GenericParam`.
+/// This can be a type param, a lifetime, or a const param.
+pub trait FromGenericParam: Sized {
+    fn from_generic_param(param: &syn::GenericParam) -> Result<Self>;
+}
+
+impl FromGenericParam for () {
+    fn from_generic_param(_param: &syn::GenericParam) -> Result<Self> {
+        Ok(())
+    }
+}
+
+impl FromGenericParam for syn::GenericParam {
+    fn from_generic_param(param: &syn::GenericParam) -> Result<Self> {
+        Ok(param.clone())
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/from_generics.rs
@@ -0,0 +1,27 @@
+use syn::Generics;
+
+use Result;
+
+/// Creates an instance by parsing an entire generics declaration, including the
+/// `where` clause.
+pub trait FromGenerics: Sized {
+    fn from_generics(generics: &Generics) -> Result<Self>;
+}
+
+impl FromGenerics for () {
+    fn from_generics(_generics: &Generics) -> Result<Self> {
+        Ok(())
+    }
+}
+
+impl FromGenerics for Generics {
+    fn from_generics(generics: &Generics) -> Result<Self> {
+        Ok(generics.clone())
+    }
+}
+
+impl<T: FromGenerics> FromGenerics for Result<T> {
+    fn from_generics(generics: &Generics) -> Result<Self> {
+        Ok(FromGenerics::from_generics(generics))
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/from_meta.rs
@@ -0,0 +1,396 @@
+use std::cell::RefCell;
+use std::collections::hash_map::{Entry, HashMap};
+use std::rc::Rc;
+use std::sync::atomic::AtomicBool;
+use std::sync::Arc;
+
+use ident_case;
+use syn::{self, Lit, Meta, NestedMeta};
+
+use {Error, Result};
+
+/// Create an instance from an item in an attribute declaration.
+///
+/// # Implementing `FromMeta`
+/// * Do not take a dependency on the `ident` of the passed-in meta item. The ident will be set by the field name of the containing struct.
+/// * Implement only the `from_*` methods that you intend to support. The default implementations will return useful errors.
+///
+/// # Provided Implementations
+/// ## bool
+///
+/// * Word with no value specified - becomes `true`.
+/// * As a boolean literal, e.g. `foo = true`.
+/// * As a string literal, e.g. `foo = "true"`.
+///
+/// ## String
+/// * As a string literal, e.g. `foo = "hello"`.
+/// * As a raw string literal, e.g. `foo = r#"hello "world""#`.
+///
+/// ## ()
+/// * Word with no value specified, e.g. `foo`. This is best used with `Option`.
+///   See `darling::util::Flag` for a more strongly-typed alternative.
+///
+/// ## Option
+/// * Any format produces `Some`.
+///
+/// ## `Result<T, darling::Error>`
+/// * Allows for fallible parsing; will populate the target field with the result of the
+///   parse attempt.
+pub trait FromMeta: Sized {
+    fn from_nested_meta(item: &NestedMeta) -> Result<Self> {
+        match *item {
+            NestedMeta::Literal(ref lit) => Self::from_value(lit),
+            NestedMeta::Meta(ref mi) => Self::from_meta(mi),
+        }
+    }
+
+    /// Create an instance from a `syn::Meta` by dispatching to the format-appropriate
+    /// trait function. This generally should not be overridden by implementers.
+    fn from_meta(item: &Meta) -> Result<Self> {
+        match *item {
+            Meta::Word(_) => Self::from_word(),
+            Meta::List(ref value) => Self::from_list(
+                &value
+                    .nested
+                    .clone()
+                    .into_iter()
+                    .collect::<Vec<syn::NestedMeta>>()[..],
+            ),
+            Meta::NameValue(ref value) => Self::from_value(&value.lit),
+        }
+    }
+
+    /// Create an instance from the presence of the word in the attribute with no
+    /// additional options specified.
+    fn from_word() -> Result<Self> {
+        Err(Error::unsupported_format("word"))
+    }
+
+    /// Create an instance from a list of nested meta items.
+    #[allow(unused_variables)]
+    fn from_list(items: &[NestedMeta]) -> Result<Self> {
+        Err(Error::unsupported_format("list"))
+    }
+
+    /// Create an instance from a literal value of either `foo = "bar"` or `foo("bar")`.
+    /// This dispatches to the appropriate method based on the type of literal encountered,
+    /// and generally should not be overridden by implementers.
+    fn from_value(value: &Lit) -> Result<Self> {
+        match *value {
+            Lit::Bool(ref b) => Self::from_bool(b.value),
+            Lit::Str(ref s) => Self::from_string(&s.value()),
+            ref _other => Err(Error::unexpected_type("other")),
+        }
+    }
+
+    /// Create an instance from a char literal in a value position.
+    #[allow(unused_variables)]
+    fn from_char(value: char) -> Result<Self> {
+        Err(Error::unexpected_type("char"))
+    }
+
+    /// Create an instance from a string literal in a value position.
+    #[allow(unused_variables)]
+    fn from_string(value: &str) -> Result<Self> {
+        Err(Error::unexpected_type("string"))
+    }
+
+    /// Create an instance from a bool literal in a value position.
+    #[allow(unused_variables)]
+    fn from_bool(value: bool) -> Result<Self> {
+        Err(Error::unexpected_type("bool"))
+    }
+}
+
+// FromMeta impls for std and syn types.
+
+impl FromMeta for () {
+    fn from_word() -> Result<Self> {
+        Ok(())
+    }
+}
+
+impl FromMeta for bool {
+    fn from_word() -> Result<Self> {
+        Ok(true)
+    }
+
+    fn from_bool(value: bool) -> Result<Self> {
+        Ok(value)
+    }
+
+    fn from_string(value: &str) -> Result<Self> {
+        value.parse().map_err(|_| Error::unknown_value(value))
+    }
+}
+
+impl FromMeta for AtomicBool {
+    fn from_meta(mi: &Meta) -> Result<Self> {
+        FromMeta::from_meta(mi).map(AtomicBool::new)
+    }
+}
+
+impl FromMeta for String {
+    fn from_string(s: &str) -> Result<Self> {
+        Ok(s.to_string())
+    }
+}
+
+impl FromMeta for u8 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for u16 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for u32 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for u64 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for usize {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for i8 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for i16 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for i32 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for i64 {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for isize {
+    fn from_string(s: &str) -> Result<Self> {
+        s.parse().map_err(|_| Error::unknown_value(s))
+    }
+}
+
+impl FromMeta for syn::Ident {
+    fn from_string(value: &str) -> Result<Self> {
+        Ok(syn::Ident::new(value, ::proc_macro2::Span::call_site()))
+    }
+}
+
+impl FromMeta for syn::Path {
+    fn from_string(value: &str) -> Result<Self> {
+        syn::parse_str(value).map_err(|_| Error::unknown_value(value))
+    }
+}
+/*
+impl FromMeta for syn::TypeParamBound {
+    fn from_string(value: &str) -> Result<Self> {
+        Ok(syn::TypeParamBound::from(value))
+    }
+}
+*/
+
+impl FromMeta for syn::Meta {
+    fn from_meta(value: &syn::Meta) -> Result<Self> {
+        Ok(value.clone())
+    }
+}
+
+impl FromMeta for syn::WhereClause {
+    fn from_string(value: &str) -> Result<Self> {
+        syn::parse_str(value).map_err(|_| Error::unknown_value(value))
+    }
+}
+
+impl FromMeta for Vec<syn::WherePredicate> {
+    fn from_string(value: &str) -> Result<Self> {
+        syn::WhereClause::from_string(&format!("where {}", value))
+            .map(|c| c.predicates.into_iter().collect())
+    }
+}
+
+impl FromMeta for ident_case::RenameRule {
+    fn from_string(value: &str) -> Result<Self> {
+        value.parse().map_err(|_| Error::unknown_value(value))
+    }
+}
+
+impl<T: FromMeta> FromMeta for Option<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        FromMeta::from_meta(item).map(Some)
+    }
+}
+
+impl<T: FromMeta> FromMeta for Box<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        FromMeta::from_meta(item).map(Box::new)
+    }
+}
+
+impl<T: FromMeta> FromMeta for Result<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        Ok(FromMeta::from_meta(item))
+    }
+}
+
+/// Parses the meta-item, and in case of error preserves a copy of the input for
+/// later analysis.
+impl<T: FromMeta> FromMeta for ::std::result::Result<T, Meta> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        T::from_meta(item)
+            .map(Ok)
+            .or_else(|_| Ok(Err(item.clone())))
+    }
+}
+
+impl<T: FromMeta> FromMeta for Rc<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        FromMeta::from_meta(item).map(Rc::new)
+    }
+}
+
+impl<T: FromMeta> FromMeta for Arc<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        FromMeta::from_meta(item).map(Arc::new)
+    }
+}
+
+impl<T: FromMeta> FromMeta for RefCell<T> {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        FromMeta::from_meta(item).map(RefCell::new)
+    }
+}
+
+impl<V: FromMeta> FromMeta for HashMap<String, V> {
+    fn from_list(nested: &[syn::NestedMeta]) -> Result<Self> {
+        let mut map = HashMap::with_capacity(nested.len());
+        for item in nested {
+            if let syn::NestedMeta::Meta(ref inner) = *item {
+                match map.entry(inner.name().to_string()) {
+                    Entry::Occupied(_) => return Err(Error::duplicate_field(&inner.name().to_string())),
+                    Entry::Vacant(entry) => {
+                        entry.insert(FromMeta::from_meta(inner).map_err(|e| e.at(inner.name()))?);
+                    }
+                }
+            }
+        }
+
+        Ok(map)
+    }
+}
+
+/// Tests for `FromMeta` implementations. Wherever the word `ignore` appears in test input,
+/// it should not be considered by the parsing.
+#[cfg(test)]
+mod tests {
+    use proc_macro2::TokenStream;
+    use syn;
+
+    use {FromMeta, Result};
+
+    /// parse a string as a syn::Meta instance.
+    fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {
+        let attribute: syn::Attribute = parse_quote!(#[#tokens]);
+        attribute.interpret_meta().ok_or("Unable to parse".into())
+    }
+
+    fn fm<T: FromMeta>(tokens: TokenStream) -> T {
+        FromMeta::from_meta(&pm(tokens).expect("Tests should pass well-formed input"))
+            .expect("Tests should pass valid input")
+    }
+
+    #[test]
+    fn unit_succeeds() {
+        assert_eq!(fm::<()>(quote!(ignore)), ());
+    }
+
+    #[test]
+    fn bool_succeeds() {
+        // word format
+        assert_eq!(fm::<bool>(quote!(ignore)), true);
+
+        // bool literal
+        assert_eq!(fm::<bool>(quote!(ignore = true)), true);
+        assert_eq!(fm::<bool>(quote!(ignore = false)), false);
+
+        // string literals
+        assert_eq!(fm::<bool>(quote!(ignore = "true")), true);
+        assert_eq!(fm::<bool>(quote!(ignore = "false")), false);
+    }
+
+    #[test]
+    fn string_succeeds() {
+        // cooked form
+        assert_eq!(&fm::<String>(quote!(ignore = "world")), "world");
+
+        // raw form
+        assert_eq!(&fm::<String>(quote!(ignore = r#"world"#)), "world");
+    }
+
+    #[test]
+    fn number_succeeds() {
+        assert_eq!(fm::<u8>(quote!(ignore = "2")), 2u8);
+        assert_eq!(fm::<i16>(quote!(ignore = "-25")), -25i16);
+    }
+
+    #[test]
+    fn meta_succeeds() {
+        use syn::Meta;
+
+        assert_eq!(
+            fm::<Meta>(quote!(hello(world, today))),
+            pm(quote!(hello(world, today))).unwrap()
+        );
+    }
+
+    #[test]
+    fn hash_map_succeeds() {
+        use std::collections::HashMap;
+
+        let comparison = {
+            let mut c = HashMap::new();
+            c.insert("hello".to_string(), true);
+            c.insert("world".to_string(), false);
+            c.insert("there".to_string(), true);
+            c
+        };
+
+        assert_eq!(
+            fm::<HashMap<String, bool>>(quote!(ignore(hello, world = false, there = "true"))),
+            comparison
+        );
+    }
+
+    /// Tests that fallible parsing will always produce an outer `Ok` (from `fm`),
+    /// and will accurately preserve the inner contents.
+    #[test]
+    fn darling_result_succeeds() {
+        fm::<Result<()>>(quote!(ignore)).unwrap();
+        fm::<Result<()>>(quote!(ignore(world))).unwrap_err();
+    }
+}
deleted file mode 100644
--- a/third_party/rust/darling_core/src/from_meta_item.rs
+++ /dev/null
@@ -1,384 +0,0 @@
-use std::cell::RefCell;
-use std::collections::hash_map::{Entry, HashMap};
-use std::rc::Rc;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use ident_case;
-use syn::{self, Lit, Meta, NestedMeta};
-
-use {Error, Result};
-
-/// Create an instance from an item in an attribute declaration.
-///
-/// # Implementing `FromMetaItem`
-/// * Do not take a dependency on the `ident` of the passed-in meta item. The ident will be set by the field name of the containing struct.
-/// * Implement only the `from_*` methods that you intend to support. The default implementations will return useful errors.
-///
-/// # Provided Implementations
-/// ## bool
-///
-/// * Word with no value specified - becomes `true`.
-/// * As a boolean literal, e.g. `foo = true`.
-/// * As a string literal, e.g. `foo = "true"`.
-///
-/// ## String
-/// * As a string literal, e.g. `foo = "hello"`.
-/// * As a raw string literal, e.g. `foo = r#"hello "world""#`.
-///
-/// ## ()
-/// * Word with no value specified, e.g. `foo`. This is best used with `Option`.
-///   See `darling::util::Flag` for a more strongly-typed alternative.
-///
-/// ## Option
-/// * Any format produces `Some`.
-///
-/// ## `Result<T, darling::Error>`
-/// * Allows for fallible parsing; will populate the target field with the result of the
-///   parse attempt.
-pub trait FromMetaItem: Sized {
-    fn from_nested_meta_item(item: &NestedMeta) -> Result<Self> {
-        match *item {
-            NestedMeta::Literal(ref lit) => Self::from_value(lit),
-            NestedMeta::Meta(ref mi) => Self::from_meta_item(mi),
-        }
-    }
-
-    /// Create an instance from a `syn::Meta` by dispatching to the format-appropriate
-    /// trait function. This generally should not be overridden by implementers.
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        match *item {
-            Meta::Word(_) => Self::from_word(),
-            Meta::List(ref value) => Self::from_list(&value.nested.clone().into_iter().collect::<Vec<syn::NestedMeta>>()[..]),
-            Meta::NameValue(ref value) => Self::from_value(&value.lit),
-        }
-    }
-
-    /// Create an instance from the presence of the word in the attribute with no
-    /// additional options specified.
-    fn from_word() -> Result<Self> {
-        Err(Error::unsupported_format("word"))
-    }
-
-    /// Create an instance from a list of nested meta items.
-    #[allow(unused_variables)]
-    fn from_list(items: &[NestedMeta]) -> Result<Self> {
-        Err(Error::unsupported_format("list"))
-    }
-
-    /// Create an instance from a literal value of either `foo = "bar"` or `foo("bar")`.
-    /// This dispatches to the appropriate method based on the type of literal encountered,
-    /// and generally should not be overridden by implementers.
-    fn from_value(value: &Lit) -> Result<Self> {
-        match *value {
-            Lit::Bool(ref b) => Self::from_bool(b.value),
-            Lit::Str(ref s) => Self::from_string(&s.value()),
-            ref _other => Err(Error::unexpected_type("other"))
-        }
-    }
-
-    /// Create an instance from a char literal in a value position.
-    #[allow(unused_variables)]
-    fn from_char(value: char) -> Result<Self> {
-        Err(Error::unexpected_type("char"))
-    }
-
-    /// Create an instance from a string literal in a value position.
-    #[allow(unused_variables)]
-    fn from_string(value: &str) -> Result<Self> {
-        Err(Error::unexpected_type("string"))
-    }
-
-    /// Create an instance from a bool literal in a value position.
-    #[allow(unused_variables)]
-    fn from_bool(value: bool) -> Result<Self> {
-        Err(Error::unexpected_type("bool"))
-    }
-}
-
-// FromMetaItem impls for std and syn types.
-
-impl FromMetaItem for () {
-    fn from_word() -> Result<Self> {
-        Ok(())
-    }
-}
-
-impl FromMetaItem for bool {
-    fn from_word() -> Result<Self> {
-        Ok(true)
-    }
-
-    fn from_bool(value: bool) -> Result<Self> {
-        Ok(value)
-    }
-
-    fn from_string(value: &str) -> Result<Self> {
-        value.parse().or_else(|_| Err(Error::unknown_value(value)))
-    }
-}
-
-impl FromMetaItem for AtomicBool {
-    fn from_meta_item(mi: &Meta) -> Result<Self> {
-        Ok(AtomicBool::new(FromMetaItem::from_meta_item(mi)?))
-    }
-}
-
-impl FromMetaItem for String {
-    fn from_string(s: &str) -> Result<Self> {
-        Ok(s.to_string())
-    }
-}
-
-impl FromMetaItem for u8 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for u16 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for u32 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for u64 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for usize {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for i8 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for i16 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for i32 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-impl FromMetaItem for i64 {
-    fn from_string(s: &str) -> Result<Self> {
-        s.parse().or_else(|_| Err(Error::unknown_value(s)))
-    }
-}
-
-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::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())
-    }
-}
-/*
-impl FromMetaItem for syn::TypeParamBound {
-    fn from_string(value: &str) -> Result<Self> {
-        Ok(syn::TypeParamBound::from(value))
-    }
-}
-*/
-
-impl FromMetaItem for syn::Meta {
-    fn from_meta_item(value: &syn::Meta) -> Result<Self> {
-        Ok(value.clone())
-    }
-}
-
-impl FromMetaItem for syn::WhereClause {
-    fn from_string(value: &str) -> Result<Self> {
-        let ret: syn::WhereClause = syn::parse_str(value).unwrap();
-        Ok(ret)
-    }
-}
-
-impl FromMetaItem for Vec<syn::WherePredicate> {
-    fn from_string(value: &str) -> Result<Self> {
-        syn::WhereClause::from_string(&format!("where {}", value)).map(|c| c.predicates.into_iter().collect())
-    }
-}
-
-impl FromMetaItem for ident_case::RenameRule {
-    fn from_string(value: &str) -> Result<Self> {
-        value.parse().or_else(|_| Err(Error::unknown_value(value)))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for Option<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(Some(FromMetaItem::from_meta_item(item)?))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for Box<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(Box::new(FromMetaItem::from_meta_item(item)?))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for Result<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(FromMetaItem::from_meta_item(item))
-    }
-}
-
-/// Parses the meta-item, and in case of error preserves a copy of the input for
-/// later analysis.
-impl<T: FromMetaItem> FromMetaItem for ::std::result::Result<T, Meta> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        T::from_meta_item(item).map(Ok).or_else(|_| Ok(Err(item.clone())))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for Rc<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(Rc::new(FromMetaItem::from_meta_item(item)?))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for Arc<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(Arc::new(FromMetaItem::from_meta_item(item)?))
-    }
-}
-
-impl<T: FromMetaItem> FromMetaItem for RefCell<T> {
-    fn from_meta_item(item: &Meta) -> Result<Self> {
-        Ok(RefCell::new(FromMetaItem::from_meta_item(item)?))
-    }
-}
-
-impl<V: FromMetaItem> FromMetaItem for HashMap<String, V> {
-    fn from_list(nested: &[syn::NestedMeta]) -> Result<Self> {
-        let mut map = HashMap::with_capacity(nested.len());
-        for item in nested {
-            if let syn::NestedMeta::Meta(ref inner) = *item {
-                match map.entry(inner.name().to_string()) {
-                    Entry::Occupied(_) => return Err(Error::duplicate_field(inner.name().as_ref())),
-                    Entry::Vacant(entry) => {
-                        entry.insert(
-                            FromMetaItem::from_meta_item(inner).map_err(|e| e.at(inner.name()))?
-                        );
-                    }
-                }
-            }
-        }
-
-        Ok(map)
-    }
-}
-
-/// Tests for `FromMetaItem` implementations. Wherever the word `ignore` appears in test input,
-/// it should not be considered by the parsing.
-#[cfg(test)]
-mod tests {
-    use syn;
-    use quote::Tokens;
-
-    use {FromMetaItem, Result};
-
-    /// parse a string as a syn::Meta instance.
-    fn pmi(tokens: Tokens) -> ::std::result::Result<syn::Meta, String> {
-        let attribute: syn::Attribute = parse_quote!(#[#tokens]);
-        attribute.interpret_meta().ok_or("Unable to parse".into())
-    }
-
-    fn fmi<T: FromMetaItem>(tokens: Tokens) -> T {
-        FromMetaItem::from_meta_item(&pmi(tokens).expect("Tests should pass well-formed input"))
-            .expect("Tests should pass valid input")
-    }
-
-    #[test]
-    fn unit_succeeds() {
-        assert_eq!(fmi::<()>(quote!(ignore)), ());
-    }
-
-    #[test]
-    fn bool_succeeds() {
-        // word format
-        assert_eq!(fmi::<bool>(quote!(ignore)), true);
-
-        // bool literal
-        assert_eq!(fmi::<bool>(quote!(ignore = true)), true);
-        assert_eq!(fmi::<bool>(quote!(ignore = false)), false);
-
-        // string literals
-        assert_eq!(fmi::<bool>(quote!(ignore = "true")), true);
-        assert_eq!(fmi::<bool>(quote!(ignore = "false")), false);
-    }
-
-    #[test]
-    fn string_succeeds() {
-        // cooked form
-        assert_eq!(&fmi::<String>(quote!(ignore = "world")), "world");
-
-        // raw form
-        assert_eq!(&fmi::<String>(quote!(ignore = r#"world"#)), "world");
-    }
-
-    #[test]
-    fn number_succeeds() {
-        assert_eq!(fmi::<u8>(quote!(ignore = "2")), 2u8);
-        assert_eq!(fmi::<i16>(quote!(ignore="-25")), -25i16);
-    }
-
-    #[test]
-    fn meta_item_succeeds() {
-        use syn::Meta;
-
-        assert_eq!(fmi::<Meta>(quote!(hello(world,today))), pmi(quote!(hello(world,today))).unwrap());
-    }
-
-    #[test]
-    fn hash_map_succeeds() {
-        use std::collections::HashMap;
-
-        let comparison = {
-            let mut c = HashMap::new();
-            c.insert("hello".to_string(), true);
-            c.insert("world".to_string(), false);
-            c.insert("there".to_string(), true);
-            c
-        };
-
-        assert_eq!(fmi::<HashMap<String, bool>>(quote!(ignore(hello, world = false, there = "true"))), comparison);
-    }
-
-    /// Tests that fallible parsing will always produce an outer `Ok` (from `fmi`),
-    /// and will accurately preserve the inner contents.
-    #[test]
-    fn darling_result_succeeds() {
-        fmi::<Result<()>>(quote!(ignore)).unwrap();
-        fmi::<Result<()>>(quote!(ignore(world))).unwrap_err();
-    }
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/from_type_param.rs
@@ -0,0 +1,32 @@
+use syn::{self, TypeParam};
+
+use Result;
+
+/// Creates an instance by parsing an individual type_param and its attributes.
+pub trait FromTypeParam: Sized {
+    fn from_type_param(type_param: &TypeParam) -> Result<Self>;
+}
+
+impl FromTypeParam for () {
+    fn from_type_param(_: &TypeParam) -> Result<Self> {
+        Ok(())
+    }
+}
+
+impl FromTypeParam for TypeParam {
+    fn from_type_param(type_param: &TypeParam) -> Result<Self> {
+        Ok(type_param.clone())
+    }
+}
+
+impl FromTypeParam for Vec<syn::Attribute> {
+    fn from_type_param(type_param: &TypeParam) -> Result<Self> {
+        Ok(type_param.attrs.clone())
+    }
+}
+
+impl FromTypeParam for syn::Ident {
+    fn from_type_param(type_param: &TypeParam) -> Result<Self> {
+        Ok(type_param.ident.clone())
+    }
+}
--- a/third_party/rust/darling_core/src/from_variant.rs
+++ b/third_party/rust/darling_core/src/from_variant.rs
@@ -25,9 +25,9 @@ impl FromVariant for syn::Ident {
         Ok(variant.ident.clone())
     }
 }
 
 impl FromVariant for Vec<syn::Attribute> {
     fn from_variant(variant: &Variant) -> Result<Self> {
         Ok(variant.attrs.clone())
     }
-}
\ No newline at end of file
+}
--- a/third_party/rust/darling_core/src/lib.rs
+++ b/third_party/rust/darling_core/src/lib.rs
@@ -2,33 +2,42 @@
 
 #[macro_use]
 extern crate quote;
 
 #[macro_use]
 extern crate syn;
 extern crate proc_macro2;
 
+extern crate fnv;
 extern crate ident_case;
 
 #[macro_use]
-mod macros;
+mod macros_private;
+#[macro_use]
+mod macros_public;
 
 pub mod ast;
 pub mod codegen;
 pub mod error;
+mod from_derive_input;
 mod from_field;
-mod from_derive_input;
-mod from_meta_item;
+mod from_generic_param;
+mod from_generics;
+mod from_meta;
+mod from_type_param;
 mod from_variant;
 pub mod options;
+pub mod usage;
 pub mod util;
 
-pub use error::{Result, Error};
+pub use error::{Error, Result};
 pub use from_derive_input::FromDeriveInput;
 pub use from_field::FromField;
-pub use from_meta_item::{FromMetaItem};
+pub use from_generic_param::FromGenericParam;
+pub use from_generics::FromGenerics;
+pub use from_meta::FromMeta;
+pub use from_type_param::FromTypeParam;
 pub use from_variant::FromVariant;
 
-#[cfg(test)]
-mod tests {
-    
-}
+// Re-export tokenizer
+#[doc(hidden)]
+pub use quote::ToTokens;
\ No newline at end of file
rename from third_party/rust/darling_core/src/macros.rs
rename to third_party/rust/darling_core/src/macros_private.rs
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/macros_public.rs
@@ -0,0 +1,98 @@
+//! Macros that should be exported from both `darling_core` and `darling`.
+//! Note that these are **sym-linked** into the main code, and so cannot declare on items that are exported differently
+//! in `darling_core` vs. `darling`.
+
+/// Generator for `UsesTypeParam` impls that unions the used type parameters of the selected fields.
+///
+/// # Usage
+/// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
+/// fields for the rest of its arguments.
+///
+/// The type of each passed-in field must implement `UsesTypeParams`, or the resulting code won't compile.
+///
+/// ```rust
+/// # extern crate syn;
+/// #
+/// # #[macro_use]
+/// # extern crate darling_core;
+/// #
+/// struct MyField {
+///     ty: syn::Type,
+/// }
+///
+/// uses_type_params!(MyField, ty);
+///
+/// fn main() {
+///     // no test run
+/// }
+/// ```
+///
+/// `darling` cannot derive this trait automatically, as it doesn't know which information extracted from
+/// proc-macro input is meant to constitute "using" the type parameter, but crate consumers should
+/// implement it by hand or using the macro.
+#[macro_export]
+macro_rules! uses_type_params {
+    ($impl_type:ty, $accessor:ident) => {
+        impl $crate::usage::UsesTypeParams for $impl_type {
+            fn uses_type_params<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::IdentSet
+            ) -> $crate::usage::IdentRefSet<'gen> {
+                self.$accessor.uses_type_params(options, type_set)
+            }
+        }
+    };
+    ($impl_type:ty, $first:ident, $($field:ident),+) => {
+        impl $crate::usage::UsesTypeParams for $impl_type {
+            fn uses_type_params<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::IdentSet
+            ) -> $crate::usage::IdentRefSet<'gen> {
+                let mut hits = self.$first.uses_type_params(options, type_set);
+                $(
+                    hits.extend(self.$field.uses_type_params(options, type_set));
+                )*
+                hits
+            }
+        }
+    };
+}
+
+/// Generator for `UsesLifetimes` impls that unions the used lifetimes of the selected fields.
+///
+/// # Usage
+/// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
+/// fields for the rest of its arguments.
+///
+/// The type of each passed-in field must implement `UsesLifetimes`, or the resulting code won't compile.
+#[macro_export]
+macro_rules! uses_lifetimes {
+    ($impl_type:ty, $accessor:ident) => {
+        impl $crate::usage::UsesLifetimes for $impl_type {
+            fn uses_lifetimes<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::LifetimeSet
+            ) -> $crate::usage::LifetimeRefSet<'gen> {
+                self.$accessor.uses_lifetimes(options, type_set)
+            }
+        }
+    };
+    ($impl_type:ty, $first:ident, $($field:ident),+) => {
+        impl $crate::usage::UsesLifetimes for $impl_type {
+            fn uses_lifetimes<'gen>(
+                &self,
+                options: &$crate::usage::Options,
+                type_set: &'gen $crate::usage::LifetimeSet
+            ) -> $crate::usage::LifetimeRefSet<'gen> {
+                let mut hits = self.$first.uses_lifetimes(options, type_set);
+                $(
+                    hits.extend(self.$field.uses_lifetimes(options, type_set));
+                )*
+                hits
+            }
+        }
+    };
+}
--- a/third_party/rust/darling_core/src/options/core.rs
+++ b/third_party/rust/darling_core/src/options/core.rs
@@ -1,17 +1,17 @@
 use ident_case::RenameRule;
 use syn;
 
-use {Result, Error, FromMetaItem};
-use ast::{Data, Style, Fields};
+use ast::{Data, Fields, Style};
 use codegen;
 use options::{DefaultExpression, InputField, InputVariant, ParseAttribute, ParseData};
+use {Error, FromMeta, Result};
 
-/// A struct or enum which should have `FromMetaItem` or `FromDeriveInput` implementations
+/// A struct or enum which should have `FromMeta` or `FromDeriveInput` implementations
 /// generated.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Core {
     /// The type identifier.
     pub ident: syn::Ident,
 
     /// The type's generics. If the type does not use any generics, this will
     /// be an empty instance.
@@ -40,64 +40,63 @@ impl Core {
     pub fn start(di: &syn::DeriveInput) -> Self {
         Core {
             ident: di.ident.clone(),
             generics: di.generics.clone(),
             data: Data::empty_from(&di.data),
             default: Default::default(),
             // See https://github.com/TedDriggs/darling/issues/10: We default to snake_case
             // for enums to help authors produce more idiomatic APIs.
-            rename_rule: if let syn::Data::Enum(_) = di.data{
+            rename_rule: if let syn::Data::Enum(_) = di.data {
                 RenameRule::SnakeCase
             } else {
                 Default::default()
             },
             map: Default::default(),
             bound: Default::default(),
         }
     }
 
     fn as_codegen_default<'a>(&'a self) -> Option<codegen::DefaultExpression<'a>> {
-        self.default.as_ref().map(|expr| {
-            match *expr {
-                DefaultExpression::Explicit(ref path) => codegen::DefaultExpression::Explicit(path),
-                DefaultExpression::Inherit |
-                DefaultExpression::Trait => codegen::DefaultExpression::Trait,
+        self.default.as_ref().map(|expr| match *expr {
+            DefaultExpression::Explicit(ref path) => codegen::DefaultExpression::Explicit(path),
+            DefaultExpression::Inherit | DefaultExpression::Trait => {
+                codegen::DefaultExpression::Trait
             }
         })
     }
 }
 
 impl ParseAttribute for Core {
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
-        match mi.name().as_ref() {
+        match mi.name().to_string().as_str() {
             "default" => {
                 if self.default.is_some() {
                     Err(Error::duplicate_field("default"))
                 } else {
-                    self.default = FromMetaItem::from_meta_item(mi)?;
+                    self.default = FromMeta::from_meta(mi)?;
                     Ok(())
                 }
             }
             "rename_all" => {
                 // WARNING: This may have been set based on body shape previously,
                 // so an overwrite may be permissible.
-                self.rename_rule = FromMetaItem::from_meta_item(mi)?;
+                self.rename_rule = FromMeta::from_meta(mi)?;
                 Ok(())
             }
             "map" => {
                 if self.map.is_some() {
                     Err(Error::duplicate_field("map"))
                 } else {
-                    self.map = FromMetaItem::from_meta_item(mi)?;
+                    self.map = FromMeta::from_meta(mi)?;
                     Ok(())
                 }
             }
             "bound" => {
-                self.bound = FromMetaItem::from_meta_item(mi)?;
+                self.bound = FromMeta::from_meta(mi)?;
                 Ok(())
             }
             n => Err(Error::unknown_field(n.as_ref())),
         }
     }
 }
 
 impl ParseData for Core {
@@ -112,19 +111,19 @@ impl ParseData for Core {
             Data::Struct(_) => panic!("Core::parse_variant should never be called for a struct"),
         }
     }
 
     fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
         let f = InputField::from_field(field, Some(&self))?;
 
         match self.data {
-            Data::Struct(Fields { style: Style::Unit, .. }) => {
-                panic!("Core::parse_field should not be called on unit")
-            }
+            Data::Struct(Fields {
+                style: Style::Unit, ..
+            }) => panic!("Core::parse_field should not be called on unit"),
             Data::Struct(Fields { ref mut fields, .. }) => {
                 fields.push(f);
                 Ok(())
             }
             Data::Enum(_) => panic!("Core::parse_field should never be called for an enum"),
         }
     }
 }
--- a/third_party/rust/darling_core/src/options/forward_attrs.rs
+++ b/third_party/rust/darling_core/src/options/forward_attrs.rs
@@ -1,12 +1,12 @@
 use syn::NestedMeta;
 
-use {FromMetaItem, Result};
 use util::IdentList;
+use {FromMeta, Result};
 
 /// A rule about which attributes to forward to the generated struct.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum ForwardAttrs {
     All,
     Only(IdentList),
 }
 
@@ -15,17 +15,17 @@ impl ForwardAttrs {
     pub fn is_empty(&self) -> bool {
         match *self {
             ForwardAttrs::All => false,
             ForwardAttrs::Only(ref list) => list.is_empty(),
         }
     }
 }
 
-impl FromMetaItem for ForwardAttrs {
+impl FromMeta for ForwardAttrs {
     fn from_word() -> Result<Self> {
         Ok(ForwardAttrs::All)
     }
 
     fn from_list(nested: &[NestedMeta]) -> Result<Self> {
         Ok(ForwardAttrs::Only(IdentList::from_list(nested)?))
     }
 }
--- a/third_party/rust/darling_core/src/options/from_derive.rs
+++ b/third_party/rust/darling_core/src/options/from_derive.rs
@@ -1,13 +1,13 @@
 use syn::{self, Ident};
 
-use {FromMetaItem, Result};
 use codegen;
-use options::{ParseAttribute, ParseData, OuterFrom, Shape};
+use options::{OuterFrom, ParseAttribute, ParseData, Shape};
+use {FromMeta, Result};
 
 #[derive(Debug)]
 pub struct FdiOptions {
     pub base: OuterFrom,
 
     /// The field on the target struct which should receive the type visibility, if any.
     pub vis: Option<Ident>,
 
@@ -22,50 +22,69 @@ pub struct FdiOptions {
 impl FdiOptions {
     pub fn new(di: &syn::DeriveInput) -> Result<Self> {
         (FdiOptions {
             base: OuterFrom::start(di),
             vis: Default::default(),
             generics: Default::default(),
             data: Default::default(),
             supports: Default::default(),
-        }).parse_attributes(&di.attrs)?.parse_body(&di.data)
+        }).parse_attributes(&di.attrs)?
+            .parse_body(&di.data)
     }
 }
 
 impl ParseAttribute for FdiOptions {
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
-        match mi.name().as_ref() {
-            "supports" => { self.supports = FromMetaItem::from_meta_item(mi)?; Ok(()) },
-            _ => self.base.parse_nested(mi)
+        match mi.name().to_string().as_str() {
+            "supports" => {
+                self.supports = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            _ => self.base.parse_nested(mi),
         }
     }
 }
 
 impl ParseData for FdiOptions {
     fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
         self.base.parse_variant(variant)
     }
 
     fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
-        match field.ident.as_ref().map(|v| v.as_ref()) {
-            Some("vis") => { self.vis = field.ident.clone(); Ok(()) }
-            Some("data") => { self.data = field.ident.clone(); Ok(()) }
-            Some("generics") => { self.generics = field.ident.clone(); Ok(()) }
-            _ => self.base.parse_field(field)
+        match field
+            .ident
+            .as_ref()
+            .map(|v| v.to_string())
+            .as_ref()
+            .map(|v| v.as_str())
+        {
+            Some("vis") => {
+                self.vis = field.ident.clone();
+                Ok(())
+            }
+            Some("data") => {
+                self.data = field.ident.clone();
+                Ok(())
+            }
+            Some("generics") => {
+                self.generics = field.ident.clone();
+                Ok(())
+            }
+            _ => self.base.parse_field(field),
         }
     }
 }
 
 impl<'a> From<&'a FdiOptions> for codegen::FromDeriveInputImpl<'a> {
     fn from(v: &'a FdiOptions) -> Self {
         codegen::FromDeriveInputImpl {
             base: (&v.base.container).into(),
-            attr_names: v.base.attr_names.as_strs(),
-            from_ident: Some(v.base.from_ident),
+            attr_names: &v.base.attr_names,
+            from_ident: v.base.from_ident,
             ident: v.base.ident.as_ref(),
             vis: v.vis.as_ref(),
             data: v.data.as_ref(),
             generics: v.generics.as_ref(),
             attrs: v.base.attrs.as_ref(),
             forward_attrs: v.base.forward_attrs.as_ref(),
             supports: v.supports.as_ref(),
         }
--- a/third_party/rust/darling_core/src/options/from_field.rs
+++ b/third_party/rust/darling_core/src/options/from_field.rs
@@ -1,57 +1,70 @@
 use syn::{self, Ident};
 
-use {Result};
 use codegen::FromFieldImpl;
-use options::{ParseAttribute, ParseData, OuterFrom};
+use options::{OuterFrom, ParseAttribute, ParseData};
+use Result;
 
 #[derive(Debug)]
 pub struct FromFieldOptions {
     pub base: OuterFrom,
     pub vis: Option<Ident>,
     pub ty: Option<Ident>,
 }
 
 impl FromFieldOptions {
     pub fn new(di: &syn::DeriveInput) -> Result<Self> {
         (FromFieldOptions {
             base: OuterFrom::start(di),
             vis: Default::default(),
             ty: Default::default(),
-        }).parse_attributes(&di.attrs)?.parse_body(&di.data)
+        }).parse_attributes(&di.attrs)?
+            .parse_body(&di.data)
     }
 }
 
 impl ParseAttribute for FromFieldOptions {
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
         self.base.parse_nested(mi)
     }
 }
 
 impl ParseData for FromFieldOptions {
     fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
         self.base.parse_variant(variant)
     }
 
     fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
-        match field.ident.as_ref().map(|v| v.as_ref()) {
-            Some("vis") => { self.vis = field.ident.clone(); Ok(()) },
-            Some("ty") => { self.ty = field.ident.clone(); Ok(()) }
-            _ => self.base.parse_field(field)
+        match field
+            .ident
+            .as_ref()
+            .map(|v| v.to_string())
+            .as_ref()
+            .map(|v| v.as_str())
+        {
+            Some("vis") => {
+                self.vis = field.ident.clone();
+                Ok(())
+            }
+            Some("ty") => {
+                self.ty = field.ident.clone();
+                Ok(())
+            }
+            _ => self.base.parse_field(field),
         }
     }
 }
 
 impl<'a> From<&'a FromFieldOptions> for FromFieldImpl<'a> {
     fn from(v: &'a FromFieldOptions) -> Self {
         FromFieldImpl {
             ident: v.base.ident.as_ref(),
             vis: v.vis.as_ref(),
             ty: v.ty.as_ref(),
             attrs: v.base.attrs.as_ref(),
             base: (&v.base.container).into(),
-            attr_names: v.base.attr_names.as_strs(),
+            attr_names: &v.base.attr_names,
             forward_attrs: v.base.forward_attrs.as_ref(),
             from_ident: v.base.from_ident,
         }
     }
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/options/from_meta.rs
@@ -0,0 +1,42 @@
+use syn;
+
+use codegen;
+use options::{Core, ParseAttribute, ParseData};
+use Result;
+
+pub struct FromMetaOptions {
+    base: Core,
+}
+
+impl FromMetaOptions {
+    pub fn new(di: &syn::DeriveInput) -> Result<Self> {
+        (FromMetaOptions {
+            base: Core::start(di),
+        }).parse_attributes(&di.attrs)?
+            .parse_body(&di.data)
+    }
+}
+
+impl ParseAttribute for FromMetaOptions {
+    fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
+        self.base.parse_nested(mi)
+    }
+}
+
+impl ParseData for FromMetaOptions {
+    fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
+        self.base.parse_variant(variant)
+    }
+
+    fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
+        self.base.parse_field(field)
+    }
+}
+
+impl<'a> From<&'a FromMetaOptions> for codegen::FromMetaImpl<'a> {
+    fn from(v: &'a FromMetaOptions) -> Self {
+        codegen::FromMetaImpl {
+            base: (&v.base).into(),
+        }
+    }
+}
deleted file mode 100644
--- a/third_party/rust/darling_core/src/options/from_meta_item.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use syn;
-
-use Result;
-use codegen;
-use options::{Core, ParseAttribute, ParseData};
-
-pub struct FmiOptions {
-    base: Core
-}
-
-impl FmiOptions {
-    pub fn new(di: &syn::DeriveInput) -> Result<Self> {
-        (FmiOptions {
-            base: Core::start(di),
-        }).parse_attributes(&di.attrs)?.parse_body(&di.data)
-    }
-}
-
-impl ParseAttribute for FmiOptions {
-    fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
-        self.base.parse_nested(mi)
-    }
-}
-
-impl ParseData for FmiOptions {
-    fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
-        self.base.parse_variant(variant)
-    }
-
-    fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
-        self.base.parse_field(field)
-    }
-}
-
-impl<'a> From<&'a FmiOptions> for codegen::FmiImpl<'a> {
-    fn from(v: &'a FmiOptions) -> Self {
-        codegen::FmiImpl {
-            base: (&v.base).into(),
-        }
-    }
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/options/from_type_param.rs
@@ -0,0 +1,70 @@
+use syn::{self, Ident};
+
+use codegen::FromTypeParamImpl;
+use options::{OuterFrom, ParseAttribute, ParseData};
+use Result;
+
+#[derive(Debug)]
+pub struct FromTypeParamOptions {
+    pub base: OuterFrom,
+    pub bounds: Option<Ident>,
+    pub default: Option<Ident>,
+}
+
+impl FromTypeParamOptions {
+    pub fn new(di: &syn::DeriveInput) -> Result<Self> {
+        (FromTypeParamOptions {
+            base: OuterFrom::start(di),
+            bounds: None,
+            default: None,
+        }).parse_attributes(&di.attrs)?
+            .parse_body(&di.data)
+    }
+}
+
+impl ParseAttribute for FromTypeParamOptions {
+    fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
+        self.base.parse_nested(mi)
+    }
+}
+
+impl ParseData for FromTypeParamOptions {
+    fn parse_variant(&mut self, variant: &syn::Variant) -> Result<()> {
+        self.base.parse_variant(variant)
+    }
+
+    fn parse_field(&mut self, field: &syn::Field) -> Result<()> {
+        match field
+            .ident
+            .as_ref()
+            .map(|v| v.to_string())
+            .as_ref()
+            .map(|v| v.as_str())
+        {
+            Some("bounds") => {
+                self.bounds = field.ident.clone();
+                Ok(())
+            }
+            Some("default") => {
+                self.default = field.ident.clone();
+                Ok(())
+            }
+            _ => self.base.parse_field(field),
+        }
+    }
+}
+
+impl<'a> From<&'a FromTypeParamOptions> for FromTypeParamImpl<'a> {
+    fn from(v: &'a FromTypeParamOptions) -> Self {
+        FromTypeParamImpl {
+            base: (&v.base.container).into(),
+            ident: v.base.ident.as_ref(),
+            attrs: v.base.attrs.as_ref(),
+            bounds: v.bounds.as_ref(),
+            default: v.default.as_ref(),
+            attr_names: &v.base.attr_names,
+            forward_attrs: v.base.forward_attrs.as_ref(),
+            from_ident: v.base.from_ident,
+        }
+    }
+}
--- a/third_party/rust/darling_core/src/options/from_variant.rs
+++ b/third_party/rust/darling_core/src/options/from_variant.rs
@@ -1,55 +1,68 @@
 use syn::{DeriveInput, Field, Ident, Meta};
 
-use {FromMetaItem, Result};
 use codegen::FromVariantImpl;
-use options::{OuterFrom, ParseAttribute, ParseData, DataShape};
+use options::{DataShape, OuterFrom, ParseAttribute, ParseData};
+use {FromMeta, Result};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct FromVariantOptions {
     pub base: OuterFrom,
     pub fields: Option<Ident>,
     pub supports: Option<DataShape>,
 }
 
 impl FromVariantOptions {
     pub fn new(di: &DeriveInput) -> Result<Self> {
         (FromVariantOptions {
             base: OuterFrom::start(di),
             fields: Default::default(),
             supports: Default::default(),
-        }).parse_attributes(&di.attrs)?.parse_body(&di.data)
+        }).parse_attributes(&di.attrs)?
+            .parse_body(&di.data)
     }
 }
 
 impl<'a> From<&'a FromVariantOptions> for FromVariantImpl<'a> {
     fn from(v: &'a FromVariantOptions) -> Self {
         FromVariantImpl {
             base: (&v.base.container).into(),
             ident: v.base.ident.as_ref(),
             fields: v.fields.as_ref(),
             attrs: v.base.attrs.as_ref(),
-            attr_names: v.base.attr_names.as_strs(),
+            attr_names: &v.base.attr_names,
             forward_attrs: v.base.forward_attrs.as_ref(),
-            from_ident: Some(v.base.from_ident),
+            from_ident: v.base.from_ident,
             supports: v.supports.as_ref(),
         }
     }
 }
 
 impl ParseAttribute for FromVariantOptions {
     fn parse_nested(&mut self, mi: &Meta) -> Result<()> {
-        match mi.name().as_ref() {
-            "supports" => { self.supports = FromMetaItem::from_meta_item(mi)?; Ok(()) }
-            _ => self.base.parse_nested(mi)
+        match mi.name().to_string().as_str() {
+            "supports" => {
+                self.supports = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            _ => self.base.parse_nested(mi),
         }
     }
 }
 
 impl ParseData for FromVariantOptions {
     fn parse_field(&mut self, field: &Field) -> Result<()> {
-        match field.ident.as_ref().map(|i| i.as_ref()) {
-            Some("fields") => { self.fields = field.ident.clone(); Ok(()) }
-            _ => self.base.parse_field(field)
+        match field
+            .ident
+            .as_ref()
+            .map(|v| v.to_string())
+            .as_ref()
+            .map(|v| v.as_str())
+        {
+            Some("fields") => {
+                self.fields = field.ident.clone();
+                Ok(())
+            }
+            _ => self.base.parse_field(field),
         }
     }
 }
--- a/third_party/rust/darling_core/src/options/input_field.rs
+++ b/third_party/rust/darling_core/src/options/input_field.rs
@@ -1,14 +1,13 @@
 use syn;
 
-use ::{FromMetaItem, Error, Result};
 use codegen;
 use options::{Core, DefaultExpression, ParseAttribute};
-
+use {Error, FromMeta, Result};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InputField {
     pub ident: syn::Ident,
     pub attr_name: Option<String>,
     pub ty: syn::Type,
     pub default: Option<DefaultExpression>,
     pub with: Option<syn::Path>,
@@ -20,35 +19,37 @@ pub struct InputField {
     pub multiple: bool,
 }
 
 impl InputField {
     /// Generate a view into this field that can be used for code generation.
     pub fn as_codegen_field<'a>(&'a self) -> codegen::Field<'a> {
         codegen::Field {
             ident: &self.ident,
-            name_in_attr: self.attr_name.as_ref().map(|n| n.as_str()).unwrap_or(self.ident.as_ref()),
+            name_in_attr: self.attr_name
+                .clone()
+                .unwrap_or(self.ident.to_string()),
             ty: &self.ty,
             default_expression: self.as_codegen_default(),
-            with_path: self.with.clone().unwrap_or(parse_quote!(::darling::FromMetaItem::from_meta_item)),
+            with_path: self.with
+                .clone()
+                .unwrap_or(parse_quote!(::darling::FromMeta::from_meta)),
             skip: self.skip,
             map: self.map.as_ref(),
             multiple: self.multiple,
         }
     }
 
     /// Generate a codegen::DefaultExpression for this field. This requires the field name
     /// in the `Inherit` case.
     fn as_codegen_default<'a>(&'a self) -> Option<codegen::DefaultExpression<'a>> {
-        self.default.as_ref().map(|expr| {
-            match *expr {
-                DefaultExpression::Explicit(ref path) => codegen::DefaultExpression::Explicit(path),
-                DefaultExpression::Inherit => codegen::DefaultExpression::Inherit(&self.ident),
-                DefaultExpression::Trait => codegen::DefaultExpression::Trait,
-            }
+        self.default.as_ref().map(|expr| match *expr {
+            DefaultExpression::Explicit(ref path) => codegen::DefaultExpression::Explicit(path),
+            DefaultExpression::Inherit => codegen::DefaultExpression::Inherit(&self.ident),
+            DefaultExpression::Trait => codegen::DefaultExpression::Trait,
         })
     }
 
     fn new(ident: syn::Ident, ty: syn::Type) -> Self {
         InputField {
             ident,
             ty,
             attr_name: None,
@@ -56,34 +57,37 @@ 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::new("__unnamed", ::proc_macro2::Span::call_site()));
+        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)
         }
     }
 
     /// Apply inherited settings from the container. This is done _after_ parsing
     /// to ensure deference to explicit field-level settings.
     fn with_inherited(mut self, parent: &Core) -> Result<Self> {
         // explicit renamings take precedence over rename rules on the container,
         // but in the absence of an explicit name we apply the rule.
         if self.attr_name.is_none() {
-            self.attr_name = Some(parent.rename_rule.apply_to_field(&self.ident));
+            self.attr_name = Some(parent.rename_rule.apply_to_field(self.ident.to_string()));
         }
 
         // Determine the default expression for this field, based on three pieces of information:
         // 1. Will we look for this field in the attribute?
         // 1. Is there a locally-defined default?
         // 1. Did the parent define a default?
         self.default = match (self.skip, self.default.is_some(), parent.default.is_some()) {
             // If we have a default, use it.
@@ -104,18 +108,36 @@ impl InputField {
         Ok(self)
     }
 }
 
 impl ParseAttribute for InputField {
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
         let name = mi.name().to_string();
         match name.as_str() {
-            "rename" => { self.attr_name = FromMetaItem::from_meta_item(mi)?; Ok(()) }
-            "default" => { self.default = FromMetaItem::from_meta_item(mi)?; Ok(()) }
-            "with" => { self.with = Some(FromMetaItem::from_meta_item(mi)?); Ok(()) }
-            "skip" => { self.skip = FromMetaItem::from_meta_item(mi)?; Ok(()) }
-            "map" => { self.map = Some(FromMetaItem::from_meta_item(mi)?); Ok(()) }
-            "multiple" => { self.multiple = FromMetaItem::from_meta_item(mi)?; Ok(()) }
+            "rename" => {
+                self.attr_name = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            "default" => {
+                self.default = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            "with" => {
+                self.with = Some(FromMeta::from_meta(mi)?);
+                Ok(())
+            }
+            "skip" => {
+                self.skip = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            "map" => {
+                self.map = Some(FromMeta::from_meta(mi)?);
+                Ok(())
+            }
+            "multiple" => {
+                self.multiple = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
             n => Err(Error::unknown_field(n)),
         }
     }
 }
--- a/third_party/rust/darling_core/src/options/input_variant.rs
+++ b/third_party/rust/darling_core/src/options/input_variant.rs
@@ -1,29 +1,31 @@
 use syn;
 
-use {FromMetaItem, Error, Result};
-use ast::{Style, Fields};
+use ast::{Fields, Style};
 use codegen;
 use options::{Core, InputField, ParseAttribute};
+use {Error, FromMeta, Result};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct InputVariant {
     ident: syn::Ident,
     attr_name: Option<String>,
     data: Fields<InputField>,
     skip: bool,
 }
 
 impl InputVariant {
     pub fn as_codegen_variant<'a>(&'a self, ty_ident: &'a syn::Ident) -> codegen::Variant<'a> {
         codegen::Variant {
             ty_ident,
             variant_ident: &self.ident,
-            name_in_attr: self.attr_name.as_ref().map(|s| s.as_str()).unwrap_or(self.ident.as_ref()),
+            name_in_attr: self.attr_name
+                .clone()
+                .unwrap_or(self.ident.to_string()),
             data: self.data.as_ref().map(InputField::as_codegen_field),
             skip: self.skip,
         }
     }
 
     pub fn from_variant(v: &syn::Variant, parent: Option<&Core>) -> Result<Self> {
         let mut starter = (InputVariant {
             ident: v.ident.clone(),
@@ -39,17 +41,17 @@ impl InputVariant {
                 for item in &fields.unnamed {
                     items.push(InputField::from_field(item, parent)?);
                 }
 
                 Fields {
                     style: v.fields.clone().into(),
                     fields: items,
                 }
-            },
+            }
             syn::Fields::Named(ref fields) => {
                 let mut items = Vec::with_capacity(fields.named.len());
                 for item in &fields.named {
                     items.push(InputField::from_field(item, parent)?);
                 }
 
                 Fields {
                     style: v.fields.clone().into(),
@@ -62,32 +64,31 @@ impl InputVariant {
             starter.with_inherited(p)
         } else {
             starter
         })
     }
 
     fn with_inherited(mut self, parent: &Core) -> Self {
         if self.attr_name.is_none() {
-            self.attr_name = Some(parent.rename_rule.apply_to_variant(&self.ident));
+            self.attr_name = Some(parent.rename_rule.apply_to_variant(self.ident.to_string()));
         }
 
         self
     }
 }
 
-
 impl ParseAttribute for InputVariant {
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
         let name = mi.name().to_string();
         match name.as_str() {
             "rename" => {
-                self.attr_name = FromMetaItem::from_meta_item(mi)?;
+                self.attr_name = FromMeta::from_meta(mi)?;
                 Ok(())
             }
             "skip" => {
-                self.skip = FromMetaItem::from_meta_item(mi)?;
+                self.skip = FromMeta::from_meta(mi)?;
                 Ok(())
             }
             n => Err(Error::unknown_field(n)),
         }
     }
 }
--- a/third_party/rust/darling_core/src/options/mod.rs
+++ b/third_party/rust/darling_core/src/options/mod.rs
@@ -1,52 +1,56 @@
 use syn;
 
-use {FromMetaItem, Result, Error};
+use {Error, FromMeta, Result};
 
 mod core;
 mod forward_attrs;
 mod from_derive;
 mod from_field;
-mod from_meta_item;
+mod from_meta;
+mod from_type_param;
 mod from_variant;
+mod input_field;
 mod input_variant;
-mod input_field;
 mod outer_from;
 mod shape;
 
 pub use self::core::Core;
 pub use self::forward_attrs::ForwardAttrs;
 pub use self::from_derive::FdiOptions;
 pub use self::from_field::FromFieldOptions;
-pub use self::from_meta_item::FmiOptions;
+pub use self::from_meta::FromMetaOptions;
+pub use self::from_type_param::FromTypeParamOptions;
 pub use self::from_variant::FromVariantOptions;
+pub use self::input_field::InputField;
 pub use self::input_variant::InputVariant;
-pub use self::input_field::InputField;
 pub use self::outer_from::OuterFrom;
 pub use self::shape::{DataShape, Shape};
 
 /// A default/fallback expression encountered in attributes during parsing.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum DefaultExpression {
     /// The value should be taken from the `default` instance of the containing struct.
     /// This is not valid in container options.
     Inherit,
     Explicit(syn::Path),
     Trait,
 }
 
 #[doc(hidden)]
-impl FromMetaItem for DefaultExpression {
+impl FromMeta for DefaultExpression {
     fn from_word() -> Result<Self> {
         Ok(DefaultExpression::Trait)
     }
 
     fn from_string(lit: &str) -> Result<Self> {
-        Ok(DefaultExpression::Explicit(syn::Path::from(lit)))
+        Ok(DefaultExpression::Explicit(
+            syn::parse_str(lit).map_err(|_| Error::unknown_value(lit))?
+        ))
     }
 }
 
 /// Middleware for extracting attribute values.
 pub trait ParseAttribute: Sized {
     fn parse_attributes(mut self, attrs: &[syn::Attribute]) -> Result<Self> {
         for attr in attrs {
             if attr.path == parse_quote!(darling) {
@@ -57,60 +61,54 @@ pub trait ParseAttribute: Sized {
         Ok(self)
     }
 
     /// Read a meta-item, and apply its values to the current instance.
     fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()>;
 }
 
 fn parse_attr<T: ParseAttribute>(attr: &syn::Attribute, target: &mut T) -> Result<()> {
-    if attr.is_sugared_doc {
-        return Ok(())
-    }
-
     match attr.interpret_meta() {
         Some(syn::Meta::List(data)) => {
             for item in data.nested {
                 if let syn::NestedMeta::Meta(ref mi) = item {
                     target.parse_nested(mi)?;
                 } else {
                     panic!("Wasn't able to parse: `{:?}`", item);
                 }
             }
 
             Ok(())
-        },
+        }
         Some(ref item) => panic!("Wasn't able to parse: `{:?}`", item),
         None => panic!("Unable to parse {:?}", attr),
     }
 }
 
 pub trait ParseData: Sized {
     fn parse_body(mut self, body: &syn::Data) -> Result<Self> {
         use syn::{Data, Fields};
 
         match *body {
-            Data::Struct(ref data) => {
-                match data.fields {
-                    Fields::Unit => Ok(self),
-                    Fields::Named(ref fields) => {
-                        for field in &fields.named {
-                            self.parse_field(field)?;
-                        }
-                        Ok(self)
+            Data::Struct(ref data) => match data.fields {
+                Fields::Unit => Ok(self),
+                Fields::Named(ref fields) => {
+                    for field in &fields.named {
+                        self.parse_field(field)?;
                     }
-                    Fields::Unnamed(ref fields) => {
-                        for field in &fields.unnamed {
-                            self.parse_field(field)?;
-                        }
+                    Ok(self)
+                }
+                Fields::Unnamed(ref fields) => {
+                    for field in &fields.unnamed {
+                        self.parse_field(field)?;
+                    }
 
-                        Ok(self)
-                    }
+                    Ok(self)
                 }
-            }
+            },
             Data::Enum(ref data) => {
                 for variant in &data.variants {
                     self.parse_variant(variant)?;
                 }
 
                 Ok(self)
             }
             Data::Union(_) => unreachable!(),
--- a/third_party/rust/darling_core/src/options/outer_from.rs
+++ b/third_party/rust/darling_core/src/options/outer_from.rs
@@ -1,13 +1,13 @@
 use syn::{self, Field, Ident, Meta};
 
-use {FromMetaItem, Result};
 use options::{Core, DefaultExpression, ForwardAttrs, ParseAttribute, ParseData};
 use util::IdentList;
+use {FromMeta, Result};
 
 /// Reusable base for `FromDeriveInput`, `FromVariant`, `FromField`, and other top-level
 /// `From*` traits.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct OuterFrom {
     /// The field on the target struct which should receive the type identifier, if any.
     pub ident: Option<Ident>,
 
@@ -37,32 +37,50 @@ impl OuterFrom {
             forward_attrs: Default::default(),
             from_ident: Default::default(),
         }
     }
 }
 
 impl ParseAttribute for OuterFrom {
     fn parse_nested(&mut self, mi: &Meta) -> Result<()> {
-        match mi.name().as_ref() {
-            "attributes" => { self.attr_names = FromMetaItem::from_meta_item(mi)?; Ok(()) }
-            "forward_attrs" => { self.forward_attrs = FromMetaItem::from_meta_item(mi)?; Ok(()) },
+        match mi.name().to_string().as_str() {
+            "attributes" => {
+                self.attr_names = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
+            "forward_attrs" => {
+                self.forward_attrs = FromMeta::from_meta(mi)?;
+                Ok(())
+            }
             "from_ident" => {
                 // HACK: Declaring that a default is present will cause fields to
                 // generate correct code, but control flow isn't that obvious.
                 self.container.default = Some(DefaultExpression::Trait);
                 self.from_ident = true;
                 Ok(())
             }
-            _ => self.container.parse_nested(mi)
+            _ => self.container.parse_nested(mi),
         }
     }
 }
 
 impl ParseData for OuterFrom {
     fn parse_field(&mut self, field: &Field) -> Result<()> {
-        match field.ident.as_ref().map(|v| v.as_ref()) {
-            Some("ident") => { self.ident = field.ident.clone(); Ok(()) }
-            Some("attrs") => { self.attrs = field.ident.clone(); Ok(()) }
-            _ => self.container.parse_field(field)
+        match field
+            .ident
+            .as_ref()
+            .map(|v| v.to_string())
+            .as_ref()
+            .map(|v| v.as_str())
+        {
+            Some("ident") => {
+                self.ident = field.ident.clone();
+                Ok(())
+            }
+            Some("attrs") => {
+                self.attrs = field.ident.clone();
+                Ok(())
+            }
+            _ => self.container.parse_field(field),
         }
     }
 }
--- a/third_party/rust/darling_core/src/options/shape.rs
+++ b/third_party/rust/darling_core/src/options/shape.rs
@@ -1,12 +1,13 @@
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::{TokenStreamExt, ToTokens};
 use syn::{Meta, NestedMeta};
 
-use {Error, FromMetaItem, Result};
+use {Error, FromMeta, Result};
 
 #[derive(Debug, Clone)]
 pub struct Shape {
     enum_values: DataShape,
     struct_values: DataShape,
     any: bool,
 }
 
@@ -24,63 +25,63 @@ impl Default for Shape {
         Shape {
             enum_values: DataShape::new("enum_"),
             struct_values: DataShape::new("struct_"),
             any: Default::default(),
         }
     }
 }
 
-impl FromMetaItem for Shape {
+impl FromMeta for Shape {
     fn from_list(items: &[NestedMeta]) -> Result<Self> {
         let mut new = Shape::default();
         for item in items {
             if let NestedMeta::Meta(Meta::Word(ref ident)) = *item {
-                let word = ident.as_ref();
+                let word = ident.to_string();
+                let word = word.as_str();
                 if word == "any" {
                     new.any = true;
-                }
-                else if word.starts_with("enum_") {
+                } else if word.starts_with("enum_") {
                     new.enum_values.set_word(word)?;
                 } else if word.starts_with("struct_") {
                     new.struct_values.set_word(word)?;
                 } else {
                     return Err(Error::unknown_value(word));
                 }
             } else {
                 return Err(Error::unsupported_format("non-word"));
             }
         }
 
         Ok(new)
     }
 }
 
 impl ToTokens for Shape {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let fn_body = if self.any == true {
             quote!(::darling::export::Ok(()))
-        }
-        else {
+        } else {
             let en = &self.enum_values;
             let st = &self.struct_values;
             quote! {
                 match *__body {
                     ::syn::Data::Enum(ref data) => {
                         fn validate_variant(data: &::syn::Fields) -> ::darling::Result<()> {
                             #en
                         }
 
                         for variant in &data.variants {
                             validate_variant(&variant.fields)?;
                         }
 
                         Ok(())
                     }
-                    ::syn::Data::Struct(ref data) => {
+                    ::syn::Data::Struct(ref struct_data) => {
+                        let data = &struct_data.fields;
                         #st
                     }
                     ::syn::Data::Union(_) => unreachable!(),
                 }
             }
         };
 
         // FIXME: Remove the &[]
@@ -139,38 +140,38 @@ impl DataShape {
                 self.any = true;
                 Ok(())
             }
             _ => Err(Error::unknown_value(word)),
         }
     }
 }
 
-impl FromMetaItem for DataShape {
+impl FromMeta for DataShape {
     fn from_list(items: &[NestedMeta]) -> Result<Self> {
         let mut new = DataShape::default();
         for item in items {
             if let NestedMeta::Meta(Meta::Word(ref ident)) = *item {
-                new.set_word(ident.as_ref())?;
+                new.set_word(ident.to_string().as_str())?;
             } else {
                 return Err(Error::unsupported_format("non-word"));
             }
         }
 
         Ok(new)
     }
 }
 
 impl ToTokens for DataShape {
-    fn to_tokens(&self, tokens: &mut Tokens) {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
         let body = if self.any {
             quote!(::darling::export::Ok(()))
         } else if self.supports_none() {
             let ty = self.prefix.trim_right_matches("_");
-            quote!(::darling::export::Err(::darling::Error::unsupported_format(#ty)))
+            quote!(::darling::export::Err(::darling::Error::unsupported_shape(#ty)))
         } else {
             let unit = match_arm("unit", self.unit);
             let newtype = match_arm("newtype", self.newtype);
             let named = match_arm("named", self.named);
             let tuple = match_arm("tuple", self.tuple);
             quote! {
                 match *data {
                     ::syn::Fields::Unit => #unit,
@@ -190,57 +191,57 @@ impl ToTokens for DataShape {
                 fn __validate_data(data: &::syn::Fields) -> ::darling::Result<()> {
                     #body
                 }
             }]);
         }
     }
 }
 
-fn match_arm(name: &'static str, is_supported: bool) -> Tokens {
+fn match_arm(name: &'static str, is_supported: bool) -> TokenStream {
     if is_supported {
         quote!(::darling::export::Ok(()))
     } else {
-        quote!(::darling::export::Err(::darling::Error::unsupported_format(#name)))
+        quote!(::darling::export::Err(::darling::Error::unsupported_shape(#name)))
     }
 }
 
 #[cfg(test)]
 mod tests {
+    use proc_macro2::TokenStream;
     use syn;
-    use quote::Tokens;
 
     use super::Shape;
-    use {FromMetaItem};
+    use FromMeta;
 
     /// parse a string as a syn::Meta instance.
-    fn pmi(tokens: Tokens) -> ::std::result::Result<syn::Meta, String> {
+    fn pm(tokens: TokenStream) -> ::std::result::Result<syn::Meta, String> {
         let attribute: syn::Attribute = parse_quote!(#[#tokens]);
         attribute.interpret_meta().ok_or("Unable to parse".into())
     }
 
-    fn fmi<T: FromMetaItem>(tokens: Tokens) -> T {
-        FromMetaItem::from_meta_item(&pmi(tokens).expect("Tests should pass well-formed input"))
+    fn fm<T: FromMeta>(tokens: TokenStream) -> T {
+        FromMeta::from_meta(&pm(tokens).expect("Tests should pass well-formed input"))
             .expect("Tests should pass valid input")
     }
 
     #[test]
     fn supports_any() {
-        let decl = fmi::<Shape>(quote!(ignore(any)));
+        let decl = fm::<Shape>(quote!(ignore(any)));
         assert_eq!(decl.any, true);
     }
 
     #[test]
     fn supports_struct() {
-        let decl = fmi::<Shape>(quote!(ignore(struct_any, struct_newtype)));
+        let decl = fm::<Shape>(quote!(ignore(struct_any, struct_newtype)));
         assert_eq!(decl.struct_values.any, true);
         assert_eq!(decl.struct_values.newtype, true);
     }
 
     #[test]
     fn supports_mixed() {
-        let decl = fmi::<Shape>(quote!(ignore(struct_newtype, enum_newtype, enum_tuple)));
+        let decl = fm::<Shape>(quote!(ignore(struct_newtype, enum_newtype, enum_tuple)));
         assert_eq!(decl.struct_values.newtype, true);
         assert_eq!(decl.enum_values.newtype, true);
         assert_eq!(decl.enum_values.tuple, true);
         assert_eq!(decl.struct_values.any, false);
     }
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/generics_ext.rs
@@ -0,0 +1,24 @@
+use syn::Generics;
+
+use usage::{IdentSet, LifetimeSet};
+
+/// Extension trait for pulling specific generics data from a generics AST representation.
+pub trait GenericsExt {
+    /// Get the set of all lifetimes declared by the syntax element.
+    /// This does not look for usage of the lifetime; see `UsesLifetimes` for that.
+    fn declared_lifetimes(&self) -> LifetimeSet;
+
+    /// Get the set of all type parameters declared by the syntax element.
+    /// This does not look for usage of the type parameter; see `UsesTypeParams` for that.
+    fn declared_type_params(&self) -> IdentSet;
+}
+
+impl GenericsExt for Generics {
+    fn declared_lifetimes(&self) -> LifetimeSet {
+        self.lifetimes().map(|lt| lt.lifetime.clone()).collect()
+    }
+
+    fn declared_type_params(&self) -> IdentSet {
+        self.type_params().map(|tp| tp.ident.clone()).collect()
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/ident_set.rs
@@ -0,0 +1,8 @@
+use fnv::FnvHashSet;
+use syn::Ident;
+
+/// A set of idents.
+pub type IdentSet = FnvHashSet<Ident>;
+
+/// A set of references to idents.
+pub type IdentRefSet<'a> = FnvHashSet<&'a Ident>;
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/lifetimes.rs
@@ -0,0 +1,322 @@
+use fnv::FnvHashSet;
+use syn::punctuated::Punctuated;
+use syn::{self, Lifetime, Type};
+
+use usage::Options;
+
+/// A set of lifetimes.
+pub type LifetimeSet = FnvHashSet<Lifetime>;
+
+/// A set of references to lifetimes.
+pub type LifetimeRefSet<'a> = FnvHashSet<&'a Lifetime>;
+
+/// Searcher for finding lifetimes in a syntax tree.
+/// This can be used to determine which lifetimes must be emitted in generated code.
+pub trait UsesLifetimes {
+    /// Returns the subset of the queried lifetimes that are used by the implementing syntax element.
+    ///
+    /// This method only accounts for direct usage by the element; indirect usage via bounds or `where`
+    /// predicates are not detected.
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a>;
+
+    /// Find all used lifetimes, then clone them and return that set.
+    fn uses_lifetimes_cloned(&self, options: &Options, lifetimes: &LifetimeSet) -> LifetimeSet {
+        self.uses_lifetimes(options, lifetimes)
+            .into_iter()
+            .cloned()
+            .collect()
+    }
+}
+
+/// Searcher for finding lifetimes in an iterator.
+///
+/// This trait extends iterators, providing a way to turn a filtered list of fields or variants into a set
+/// of lifetimes.
+pub trait CollectLifetimes {
+    /// Consume an iterator, accumulating all lifetimes in the elements which occur in `lifetimes`.
+    fn collect_lifetimes<'a>(
+        self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a>;
+
+    /// Consume an iterator using `collect_lifetimes`, then clone all found lifetimes and return that set.
+    fn collect_lifetimes_cloned(self, options: &Options, lifetimes: &LifetimeSet) -> LifetimeSet;
+}
+
+impl<'i, I, T> CollectLifetimes for T
+where
+    T: IntoIterator<Item = &'i I>,
+    I: 'i + UsesLifetimes,
+{
+    fn collect_lifetimes<'a>(
+        self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.into_iter()
+            .fold(Default::default(), |mut state, value| {
+                state.extend(value.uses_lifetimes(options, lifetimes));
+                state
+            })
+    }
+
+    fn collect_lifetimes_cloned(self, options: &Options, lifetimes: &LifetimeSet) -> LifetimeSet {
+        self.collect_lifetimes(options, lifetimes)
+            .into_iter()
+            .cloned()
+            .collect()
+    }
+}
+
+impl<T: UsesLifetimes> UsesLifetimes for Vec<T> {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.collect_lifetimes(options, lifetimes)
+    }
+}
+
+impl<T: UsesLifetimes, U> UsesLifetimes for Punctuated<T, U> {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.collect_lifetimes(options, lifetimes)
+    }
+}
+
+impl<T: UsesLifetimes> UsesLifetimes for Option<T> {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.as_ref().map_or_else(
+            || Default::default(),
+            |v| v.uses_lifetimes(options, lifetimes),
+        )
+    }
+}
+
+impl UsesLifetimes for Lifetime {
+    fn uses_lifetimes<'a>(&self, _: &Options, lifetimes: &'a LifetimeSet) -> LifetimeRefSet<'a> {
+        lifetimes.iter().filter(|lt| *lt == self).collect()
+    }
+}
+
+uses_lifetimes!(syn::AngleBracketedGenericArguments, args);
+uses_lifetimes!(syn::BareFnArg, ty);
+uses_lifetimes!(syn::Binding, ty);
+uses_lifetimes!(syn::BoundLifetimes, lifetimes);
+uses_lifetimes!(syn::Constraint, bounds);
+uses_lifetimes!(syn::DataEnum, variants);
+uses_lifetimes!(syn::DataStruct, fields);
+uses_lifetimes!(syn::DataUnion, fields);
+uses_lifetimes!(syn::Field, ty);
+uses_lifetimes!(syn::FieldsNamed, named);
+uses_lifetimes!(syn::LifetimeDef, lifetime, bounds);
+uses_lifetimes!(syn::ParenthesizedGenericArguments, inputs, output);
+uses_lifetimes!(syn::Path, segments);
+uses_lifetimes!(syn::PathSegment, arguments);
+uses_lifetimes!(syn::PredicateEq, lhs_ty, rhs_ty);
+uses_lifetimes!(syn::PredicateLifetime, lifetime, bounds);
+uses_lifetimes!(syn::PredicateType, lifetimes, bounded_ty, bounds);
+uses_lifetimes!(syn::QSelf, ty);
+uses_lifetimes!(syn::TraitBound, path, lifetimes);
+uses_lifetimes!(syn::TypeArray, elem);
+uses_lifetimes!(syn::TypeBareFn, inputs, output);
+uses_lifetimes!(syn::TypeGroup, elem);
+uses_lifetimes!(syn::TypeImplTrait, bounds);
+uses_lifetimes!(syn::TypeParen, elem);
+uses_lifetimes!(syn::TypePtr, elem);
+uses_lifetimes!(syn::TypeReference, lifetime, elem);
+uses_lifetimes!(syn::TypeSlice, elem);
+uses_lifetimes!(syn::TypeTuple, elems);
+uses_lifetimes!(syn::TypeTraitObject, bounds);
+uses_lifetimes!(syn::Variant, fields);
+
+impl UsesLifetimes for syn::Data {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            syn::Data::Struct(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::Data::Enum(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::Data::Union(ref v) => v.uses_lifetimes(options, lifetimes),
+        }
+    }
+}
+
+impl UsesLifetimes for Type {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            Type::Slice(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Array(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Ptr(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Reference(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::BareFn(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Tuple(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Path(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Paren(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Group(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::TraitObject(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::ImplTrait(ref v) => v.uses_lifetimes(options, lifetimes),
+            Type::Macro(_) | Type::Verbatim(_) | Type::Infer(_) | Type::Never(_) => {
+                Default::default()
+            }
+        }
+    }
+}
+
+impl UsesLifetimes for syn::Fields {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        self.collect_lifetimes(options, lifetimes)
+    }
+}
+
+impl UsesLifetimes for syn::TypePath {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        let mut hits = self.path.uses_lifetimes(options, lifetimes);
+
+        if options.include_type_path_qself() {
+            hits.extend(self.qself.uses_lifetimes(options, lifetimes));
+        }
+
+        hits
+    }
+}
+
+impl UsesLifetimes for syn::ReturnType {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        if let syn::ReturnType::Type(_, ref ty) = *self {
+            ty.uses_lifetimes(options, lifetimes)
+        } else {
+            Default::default()
+        }
+    }
+}
+
+impl UsesLifetimes for syn::PathArguments {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            syn::PathArguments::None => Default::default(),
+            syn::PathArguments::AngleBracketed(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::PathArguments::Parenthesized(ref v) => v.uses_lifetimes(options, lifetimes),
+        }
+    }
+}
+
+impl UsesLifetimes for syn::WherePredicate {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            syn::WherePredicate::Type(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::WherePredicate::Lifetime(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::WherePredicate::Eq(ref v) => v.uses_lifetimes(options, lifetimes),
+        }
+    }
+}
+
+impl UsesLifetimes for syn::GenericArgument {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            syn::GenericArgument::Type(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::GenericArgument::Binding(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::GenericArgument::Lifetime(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::GenericArgument::Constraint(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::GenericArgument::Const(_) => Default::default(),
+        }
+    }
+}
+
+impl UsesLifetimes for syn::TypeParamBound {
+    fn uses_lifetimes<'a>(
+        &self,
+        options: &Options,
+        lifetimes: &'a LifetimeSet,
+    ) -> LifetimeRefSet<'a> {
+        match *self {
+            syn::TypeParamBound::Trait(ref v) => v.uses_lifetimes(options, lifetimes),
+            syn::TypeParamBound::Lifetime(ref v) => v.uses_lifetimes(options, lifetimes),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use proc_macro2::Span;
+    use syn::{self, DeriveInput};
+
+    use super::UsesLifetimes;
+    use usage::GenericsExt;
+    use usage::Purpose::*;
+
+    fn parse(src: &str) -> DeriveInput {
+        syn::parse_str(src).unwrap()
+    }
+
+    #[test]
+    fn struct_named() {
+        let input = parse("struct Foo<'a, 'b: 'a> { parent: &'b Bar, child: &'a Baz, }");
+        let omitted = syn::Lifetime::new("'c", Span::call_site());
+
+        let lifetimes = {
+            let mut lt = input.generics.declared_lifetimes();
+            lt.insert(omitted);
+            lt
+        };
+
+        let matches = input.data.uses_lifetimes(&BoundImpl.into(), &lifetimes);
+        assert_eq!(matches.len(), 2);
+    }
+
+    #[test]
+    fn qself() {
+        let input = parse(
+            "struct Foo<'a, 'b: 'a> { parent: &'b Bar, child: <Bar<'a> as MyIterator>::Item, }",
+        );
+        let lifetimes = input.generics.declared_lifetimes();
+        let matches = input.data.uses_lifetimes(&BoundImpl.into(), &lifetimes);
+        assert_eq!(matches.len(), 1);
+
+        let decl_matches = input.data.uses_lifetimes(&Declare.into(), &lifetimes);
+        assert_eq!(decl_matches.len(), 2);
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/mod.rs
@@ -0,0 +1,111 @@
+//! Traits and types used for tracking the usage of generic parameters through a proc-macro input.
+//!
+//! When generating trait impls, libraries often want to automatically figure out which type parameters
+//! are used in which fields, and then emit bounds that will produce the most permissive compilable
+//! code.
+//!
+//! # Usage
+//!
+//! ## Example 1: Filtering
+//! This example accepts a proc-macro input, then finds all lifetimes and type parameters used
+//! by private fields.
+//!
+//! ```rust
+//! # extern crate darling_core;
+//! # extern crate syn;
+//! #
+//! # // in real-world usage, import from `darling`
+//! # use darling_core::usage::{self, CollectLifetimes, CollectTypeParams, GenericsExt, Purpose};
+//! # use syn::{Data, DeriveInput, GenericParam, Generics, Visibility};
+//! #
+//! # #[allow(dead_code)]
+//! fn process(input: &DeriveInput) -> Generics {
+//!     let type_params = input.generics.declared_type_params();
+//!     let lifetimes = input.generics.declared_lifetimes();
+//!
+//!     let mut ret_generics = input.generics.clone();
+//!
+//!     if let Data::Struct(ref body) = input.data {
+//!         let internal_fields = body
+//!             .fields
+//!             .iter()
+//!             .filter(|field| field.vis == Visibility::Inherited)
+//!             .collect::<Vec<_>>();
+//!
+//!         let int_type_params = internal_fields
+//!             .collect_type_params(&Purpose::BoundImpl.into(), &type_params);
+//!
+//!         // We could reuse the vec from above, but here we'll instead
+//!         // directly consume the chained iterator.
+//!         let int_lifetimes = body
+//!             .fields
+//!             .iter()
+//!             .filter(|field| field.vis == Visibility::Inherited)
+//!             .collect_lifetimes(&Purpose::BoundImpl.into(), &lifetimes);
+//!
+//!
+//!         ret_generics.params = ret_generics
+//!             .params
+//!             .into_iter()
+//!             .filter(|gp| {
+//!                 match gp {
+//!                     GenericParam::Type(ref ty) => int_type_params.contains(&ty.ident),
+//!                     GenericParam::Lifetime(ref lt) => int_lifetimes.contains(&lt.lifetime),
+//!                     _ => true,
+//!                 }
+//!             })
+//!             .collect();
+//!     }
+//!
+//!     ret_generics
+//! }
+//!
+//! # fn main() {}
+//! ```
+//!
+//! ## Example 2: Integrating with `FromDeriveInput`
+//! It is possible to use `darling`'s magic fields feature in tandem with the `usage` feature set.
+//! While there is no custom derive for `UsesTypeParams` or `UsesLifetimes`, there are macros to
+//! generate impls.
+//!
+//! ```rust,ignore
+//! #![allow(dead_code)]
+//!
+//! #[derive(FromField)]
+//! #[darling(attributes(speak))]
+//! struct SpeakerField {
+//!     ident: Option<syn::Ident>,
+//!     ty: syn::Type,
+//!     #[darling(default)]
+//!     volume: Option<u32>,
+//! }
+//!
+//! uses_type_params!(SpeakerField, ty);
+//! uses_lifetimes!(SpeakerField, ty);
+//!
+//! #[derive(FromDeriveInput)]
+//! struct SpeakerOptions {
+//!     generics: syn::Generics,
+//!     data: darling::ast::Data<darling::util::Ignored, SpeakerField>,
+//! }
+//! ```
+//!
+//! At this point, you are able to call `uses_type_params` on `SpeakerOptions.data`, or any filtered
+//! view of it. `darling` internally uses this in conjunction with the `skip` meta-item to determine
+//! which type parameters don't require the `FromMeta` bound in generated impls.
+//!
+//! **Note:** If you are performing operations referencing generic params in meta-items parsed by `darling`,
+//! you should determine if those impact the emitted code and wire up `UsesTypeParams` accordingly for
+//! your field/variant.
+
+mod generics_ext;
+mod ident_set;
+mod lifetimes;
+mod options;
+mod type_params;
+
+pub use self::generics_ext::GenericsExt;
+pub use self::ident_set::{IdentRefSet, IdentSet};
+pub use self::lifetimes::{CollectLifetimes, LifetimeRefSet, LifetimeSet, UsesLifetimes};
+pub use self::options::{Options, Purpose};
+pub use self::type_params::{CollectTypeParams, UsesTypeParams};
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/options.rs
@@ -0,0 +1,58 @@
+/// The goal of tracing generic parameter usage.
+///
+/// Not all uses of type parameters imply a need to add bounds to a generated trait impl.
+/// For example, a field of type `<Vec<T> as a::b::Trait>::Associated` does not need a
+/// `where T: Serialize` bound in `serde`.
+/// However, a proc macro that is attempting to generate a helper struct _would_ need to
+/// know about this usage, or else the generated code would reference an unknown type `T`
+/// and fail to compile.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum Purpose {
+    /// The tracing is being used to generate an `impl` block.
+    ///
+    /// Uses such as `syn::TypePath.qself` will _not_ be returned.
+    BoundImpl,
+    /// The tracing is being used to generate a new struct or enum.
+    ///
+    /// All uses will be returned.
+    Declare,
+}
+
+/// Control struct for searching type parameters.
+///
+/// This acts as the search context, preserving information that might have been
+/// kept on a visitor in a different implementation.
+/// Trait implementers are required to pass this through on any invocations they make.
+///
+/// # Usage
+/// For extensibility, `Options` hides all of its fields from consumers.
+/// To create an instance, use the `From<Purpose>` trait implementation:
+///
+/// ```rust
+/// # use darling_core::usage::{Options, Purpose};
+/// let opts: Options = Purpose::BoundImpl.into();
+/// assert!(!opts.include_type_path_qself());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Options {
+    purpose: Purpose,
+    #[doc(hidden)]
+    __nonexhaustive: (),
+}
+
+impl From<Purpose> for Options {
+    fn from(purpose: Purpose) -> Self {
+        Self {
+            purpose,
+            __nonexhaustive: (),
+        }
+    }
+}
+
+impl Options {
+    /// Returns `true` if the implementer of `UseTypeParams` should search
+    /// `<___ as ...>::...` when looking for type parameter uses.
+    pub fn include_type_path_qself(&self) -> bool {
+        self.purpose == Purpose::Declare
+    }
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/usage/type_params.rs
@@ -0,0 +1,362 @@
+use syn::punctuated::Punctuated;
+use syn::{self, Ident, Type};
+
+use usage::{IdentRefSet, IdentSet, Options};
+
+/// Searcher for finding type params in a syntax tree.
+/// This can be used to determine if a given type parameter needs to be bounded in a generated impl.
+pub trait UsesTypeParams {
+    /// Returns the subset of the queried type parameters that are used by the implementing syntax element.
+    ///
+    /// This method only accounts for direct usage by the element; indirect usage via bounds or `where`
+    /// predicates are not detected.
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a>;
+
+    /// Find all type params using `uses_type_params`, then clone the found values and return the set.
+    fn uses_type_params_cloned(&self, options: &Options, type_set: &IdentSet) -> IdentSet {
+        self.uses_type_params(options, type_set)
+            .into_iter()
+            .cloned()
+            .collect()
+    }
+}
+
+/// Searcher for finding type params in an iterator.
+///
+/// This trait extends iterators, providing a way to turn a filtered list of fields or variants into a set
+/// of type parameter idents.
+pub trait CollectTypeParams {
+    /// Consume an iterator, accumulating all type parameters in the elements which occur in `type_set`.
+    fn collect_type_params<'a>(self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a>;
+
+    /// Consume an iterator using `collect_type_params`, then clone all found type params and return that set.
+    fn collect_type_params_cloned(self, options: &Options, type_set: &IdentSet) -> IdentSet;
+}
+
+impl<'i, T, I> CollectTypeParams for T
+where
+    T: IntoIterator<Item = &'i I>,
+    I: 'i + UsesTypeParams,
+{
+    fn collect_type_params<'a>(self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        self.into_iter().fold(
+            IdentRefSet::with_capacity_and_hasher(type_set.len(), Default::default()),
+            |state, value| union_in_place(state, value.uses_type_params(options, type_set)),
+        )
+    }
+
+    fn collect_type_params_cloned(self, options: &Options, type_set: &IdentSet) -> IdentSet {
+        self.collect_type_params(options, type_set)
+            .into_iter()
+            .cloned()
+            .collect()
+    }
+}
+
+/// Insert the contents of `right` into `left`.
+fn union_in_place<'a>(mut left: IdentRefSet<'a>, right: IdentRefSet<'a>) -> IdentRefSet<'a> {
+    left.extend(right);
+
+    left
+}
+
+impl UsesTypeParams for () {
+    fn uses_type_params<'a>(&self, _options: &Options, _type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        Default::default()
+    }
+}
+
+impl<T: UsesTypeParams> UsesTypeParams for Option<T> {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        self.as_ref()
+            .map(|v| v.uses_type_params(options, type_set))
+            .unwrap_or_default()
+    }
+}
+
+impl<T: UsesTypeParams> UsesTypeParams for Vec<T> {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        self.collect_type_params(options, type_set)
+    }
+}
+
+impl<T: UsesTypeParams, U> UsesTypeParams for Punctuated<T, U> {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        self.collect_type_params(options, type_set)
+    }
+}
+
+uses_type_params!(syn::AngleBracketedGenericArguments, args);
+uses_type_params!(syn::BareFnArg, ty);
+uses_type_params!(syn::Binding, ty);
+uses_type_params!(syn::Constraint, bounds);
+uses_type_params!(syn::DataEnum, variants);
+uses_type_params!(syn::DataStruct, fields);
+uses_type_params!(syn::DataUnion, fields);
+uses_type_params!(syn::Field, ty);
+uses_type_params!(syn::FieldsNamed, named);
+uses_type_params!(syn::ParenthesizedGenericArguments, inputs, output);
+uses_type_params!(syn::PredicateEq, lhs_ty, rhs_ty);
+uses_type_params!(syn::PredicateType, bounded_ty, bounds);
+uses_type_params!(syn::QSelf, ty);
+uses_type_params!(syn::TraitBound, path);
+uses_type_params!(syn::TypeArray, elem);
+uses_type_params!(syn::TypeBareFn, inputs, output);
+uses_type_params!(syn::TypeGroup, elem);
+uses_type_params!(syn::TypeImplTrait, bounds);
+uses_type_params!(syn::TypeParen, elem);
+uses_type_params!(syn::TypePtr, elem);
+uses_type_params!(syn::TypeReference, elem);
+uses_type_params!(syn::TypeSlice, elem);
+uses_type_params!(syn::TypeTuple, elems);
+uses_type_params!(syn::TypeTraitObject, bounds);
+uses_type_params!(syn::Variant, fields);
+
+impl UsesTypeParams for syn::Data {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            syn::Data::Struct(ref v) => v.uses_type_params(options, type_set),
+            syn::Data::Enum(ref v) => v.uses_type_params(options, type_set),
+            syn::Data::Union(ref v) => v.uses_type_params(options, type_set),
+        }
+    }
+}
+
+impl UsesTypeParams for syn::Fields {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        self.collect_type_params(options, type_set)
+    }
+}
+
+/// Check if an Ident exactly matches one of the sought-after type parameters.
+impl UsesTypeParams for Ident {
+    fn uses_type_params<'a>(&self, _options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        type_set.iter().filter(|v| *v == self).collect()
+    }
+}
+
+impl UsesTypeParams for syn::ReturnType {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        if let syn::ReturnType::Type(_, ref ty) = *self {
+            ty.uses_type_params(options, type_set)
+        } else {
+            Default::default()
+        }
+    }
+}
+
+impl UsesTypeParams for Type {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            Type::Slice(ref v) => v.uses_type_params(options, type_set),
+            Type::Array(ref v) => v.uses_type_params(options, type_set),
+            Type::Ptr(ref v) => v.uses_type_params(options, type_set),
+            Type::Reference(ref v) => v.uses_type_params(options, type_set),
+            Type::BareFn(ref v) => v.uses_type_params(options, type_set),
+            Type::Tuple(ref v) => v.uses_type_params(options, type_set),
+            Type::Path(ref v) => v.uses_type_params(options, type_set),
+            Type::Paren(ref v) => v.uses_type_params(options, type_set),
+            Type::Group(ref v) => v.uses_type_params(options, type_set),
+            Type::TraitObject(ref v) => v.uses_type_params(options, type_set),
+            Type::ImplTrait(ref v) => v.uses_type_params(options, type_set),
+            Type::Macro(_) | Type::Verbatim(_) | Type::Infer(_) | Type::Never(_) => {
+                Default::default()
+            }
+        }
+    }
+}
+
+impl UsesTypeParams for syn::TypePath {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        let hits = self.path.uses_type_params(options, type_set);
+
+        if options.include_type_path_qself() {
+            union_in_place(hits, self.qself.uses_type_params(options, type_set))
+        } else {
+            hits
+        }
+    }
+}
+
+impl UsesTypeParams for syn::Path {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        // Not sure if this is even possible, but a path with no segments definitely
+        // can't use type parameters.
+        if self.segments.is_empty() {
+            return Default::default();
+        }
+
+        // A path segment ident can only match if it is not global and it is the first segment
+        // in the path.
+        let ident_hits = if self.leading_colon.is_none() {
+            self.segments[0].ident.uses_type_params(options, type_set)
+        } else {
+            Default::default()
+        };
+
+        // Merge ident hit, if any, with all hits from path arguments
+        self.segments.iter().fold(ident_hits, |state, segment| {
+            union_in_place(state, segment.arguments.uses_type_params(options, type_set))
+        })
+    }
+}
+
+impl UsesTypeParams for syn::PathArguments {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            syn::PathArguments::None => Default::default(),
+            syn::PathArguments::AngleBracketed(ref v) => v.uses_type_params(options, type_set),
+            syn::PathArguments::Parenthesized(ref v) => v.uses_type_params(options, type_set),
+        }
+    }
+}
+
+impl UsesTypeParams for syn::WherePredicate {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            syn::WherePredicate::Lifetime(_) => Default::default(),
+            syn::WherePredicate::Type(ref v) => v.uses_type_params(options, type_set),
+            syn::WherePredicate::Eq(ref v) => v.uses_type_params(options, type_set),
+        }
+    }
+}
+
+impl UsesTypeParams for syn::GenericArgument {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            syn::GenericArgument::Type(ref v) => v.uses_type_params(options, type_set),
+            syn::GenericArgument::Binding(ref v) => v.uses_type_params(options, type_set),
+            syn::GenericArgument::Constraint(ref v) => v.uses_type_params(options, type_set),
+            syn::GenericArgument::Const(_) | syn::GenericArgument::Lifetime(_) => {
+                Default::default()
+            }
+        }
+    }
+}
+
+impl UsesTypeParams for syn::TypeParamBound {
+    fn uses_type_params<'a>(&self, options: &Options, type_set: &'a IdentSet) -> IdentRefSet<'a> {
+        match *self {
+            syn::TypeParamBound::Trait(ref v) => v.uses_type_params(options, type_set),
+            syn::TypeParamBound::Lifetime(_) => Default::default(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use proc_macro2::Span;
+    use syn::{self, Ident};
+
+    use super::UsesTypeParams;
+    use usage::IdentSet;
+    use usage::Purpose::*;
+
+    fn given_src(src: &str) -> syn::DeriveInput {
+        syn::parse_str(src).unwrap()
+    }
+
+    fn ident_set(idents: Vec<&str>) -> IdentSet {
+        idents
+            .into_iter()
+            .map(|s| Ident::new(s, Span::call_site()))
+            .collect()
+    }
+
+    #[test]
+    fn finds_simple() {
+        let input = given_src("struct Foo<T, U>(T, i32, A, U);");
+        let generics = ident_set(vec!["T", "U", "X"]);
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+        assert_eq!(matches.len(), 2);
+        assert!(matches.contains::<Ident>(&parse_quote!(T)));
+        assert!(matches.contains::<Ident>(&parse_quote!(U)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(X)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(A)));
+    }
+
+    #[test]
+    fn finds_named() {
+        let input = given_src(
+            r#"
+        struct Foo<T, U = usize> {
+            bar: T,
+            world: U,
+        }
+        "#,
+        );
+
+        let generics = ident_set(vec!["T", "U", "X"]);
+
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+
+        assert_eq!(matches.len(), 2);
+        assert!(matches.contains::<Ident>(&parse_quote!(T)));
+        assert!(matches.contains::<Ident>(&parse_quote!(U)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(X)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(A)));
+    }
+
+    #[test]
+    fn finds_as_type_arg() {
+        let input = given_src(
+            r#"
+        struct Foo<T, U> {
+            bar: T,
+            world: Vec<U>,
+        }
+        "#,
+        );
+
+        let generics = ident_set(vec!["T", "U", "X"]);
+
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+
+        assert_eq!(matches.len(), 2);
+        assert!(matches.contains::<Ident>(&parse_quote!(T)));
+        assert!(matches.contains::<Ident>(&parse_quote!(U)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(X)));
+        assert!(!matches.contains::<Ident>(&parse_quote!(A)));
+    }
+
+    #[test]
+    fn associated_type() {
+        let input = given_src("struct Foo<'a, T> where T: Iterator { peek: T::Item }");
+        let generics = ident_set(vec!["T", "INTO"]);
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+        assert_eq!(matches.len(), 1);
+    }
+
+    #[test]
+    fn box_fn_output() {
+        let input = given_src("struct Foo<T>(Box<Fn() -> T>);");
+        let generics = ident_set(vec!["T"]);
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+        assert_eq!(matches.len(), 1);
+        assert!(matches.contains::<Ident>(&parse_quote!(T)));
+    }
+
+    #[test]
+    fn box_fn_input() {
+        let input = given_src("struct Foo<T>(Box<Fn(&T) -> ()>);");
+        let generics = ident_set(vec!["T"]);
+        let matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+        assert_eq!(matches.len(), 1);
+        assert!(matches.contains::<Ident>(&parse_quote!(T)));
+    }
+
+    /// Test that `syn::TypePath` is correctly honoring the different modes a
+    /// search can execute in.
+    #[test]
+    fn qself_vec() {
+        let input = given_src("struct Foo<T>(<Vec<T> as a::b::Trait>::AssociatedItem);");
+        let generics = ident_set(vec!["T", "U"]);
+
+        let bound_matches = input.data.uses_type_params(&BoundImpl.into(), &generics);
+        assert_eq!(bound_matches.len(), 0);
+
+        let declare_matches = input.data.uses_type_params(&Declare.into(), &generics);
+        assert_eq!(declare_matches.len(), 1);
+        assert!(declare_matches.contains::<Ident>(&parse_quote!(T)));
+    }
+}
--- a/third_party/rust/darling_core/src/util/ident_list.rs
+++ b/third_party/rust/darling_core/src/util/ident_list.rs
@@ -1,37 +1,38 @@
 use std::ops::Deref;
-
-use syn::{Ident, NestedMeta, Meta};
+use std::string::ToString;
 
-use {FromMetaItem, Result, Error};
+use syn::{Ident, Meta, NestedMeta};
 
-/// A list of `syn::Ident` instances. This type is used to extract a list of words from an 
+use {Error, FromMeta, Result};
+
+/// A list of `syn::Ident` instances. This type is used to extract a list of words from an
 /// attribute.
 ///
 /// # Usage
-/// An `IdentList` field on a struct implementing `FromMetaItem` will turn `#[builder(derive(Debug, Clone))]` into:
+/// An `IdentList` field on a struct implementing `FromMeta` will turn `#[builder(derive(Debug, Clone))]` into:
 ///
 /// ```rust,ignore
 /// StructOptions {
 ///     derive: IdentList(vec![syn::Ident::new("Debug"), syn::Ident::new("Clone")])
 /// }
 /// ```
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct IdentList(Vec<Ident>);
 
 impl IdentList {
     /// Create a new list.
     pub fn new<T: Into<Ident>>(vals: Vec<T>) -> Self {
         IdentList(vals.into_iter().map(T::into).collect())
     }
 
-    /// Creates a view of the contained identifiers as `&str`s.
-    pub fn as_strs<'a>(&'a self) -> Vec<&'a str> {
-        self.iter().map(|i| i.as_ref()).collect()
+    /// Create a new `Vec` containing the string representation of each ident.
+    pub fn to_strings(&self) -> Vec<String> {
+        self.0.iter().map(ToString::to_string).collect()
     }
 }
 
 impl Deref for IdentList {
     type Target = Vec<Ident>;
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -39,22 +40,22 @@ impl Deref for IdentList {
 }
 
 impl From<Vec<Ident>> for IdentList {
     fn from(v: Vec<Ident>) -> Self {
         IdentList(v)
     }
 }
 
-impl FromMetaItem for IdentList {
+impl FromMeta for IdentList {
     fn from_list(v: &[NestedMeta]) -> Result<Self> {
         let mut idents = Vec::with_capacity(v.len());
         for nmi in v {
             if let NestedMeta::Meta(Meta::Word(ref ident)) = *nmi {
                 idents.push(ident.clone());
             } else {
-                return Err(Error::unexpected_type("non-word"))
+                return Err(Error::unexpected_type("non-word"));
             }
         }
 
         Ok(IdentList(idents))
     }
 }
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/util/ident_string.rs
@@ -0,0 +1,148 @@
+use std::fmt;
+
+use proc_macro2::{Span, TokenStream};
+use quote::ToTokens;
+use syn::{Ident, Meta};
+
+use {FromMeta, Result};
+
+/// A wrapper for an `Ident` which also keeps the value as a string.
+///
+/// This struct can be used to perform string comparisons and operations.
+#[derive(Clone, Hash, PartialOrd, Ord)]
+pub struct IdentString {
+    ident: Ident,
+    string: String,
+}
+
+impl IdentString {
+    /// Create a new `IdentString`.
+    pub fn new(ident: Ident) -> Self {
+        IdentString {
+            string: ident.to_string(),
+            ident,
+        }
+    }
+
+    /// Get the ident as a `proc_macro2::Ident`.
+    pub fn as_ident(&self) -> &Ident {
+        &self.ident
+    }
+
+    /// Get the ident as a string.
+    pub fn as_str(&self) -> &str {
+        &self.string
+    }
+
+    /// Get the location of this `Ident` in source.
+    pub fn span(&self) -> Span {
+        self.ident.span()
+    }
+
+    /// Apply some transform to the ident's string representation.
+    ///
+    /// # Panics
+    /// This will panic if the transform produces an invalid ident.
+    pub fn map<F, S>(self, map_fn: F) -> Self
+    where
+        F: FnOnce(String) -> S,
+        S: AsRef<str>,
+    {
+        let span = self.span();
+        let string = map_fn(self.string);
+        Ident::new(string.as_ref(), span).into()
+    }
+}
+
+impl AsRef<Ident> for IdentString {
+    fn as_ref(&self) -> &Ident {
+        self.as_ident()
+    }
+}
+
+impl AsRef<str> for IdentString {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl From<Ident> for IdentString {
+    fn from(ident: Ident) -> Self {
+        IdentString::new(ident)
+    }
+}
+
+impl From<IdentString> for Ident {
+    fn from(v: IdentString) -> Ident {
+        v.ident
+    }
+}
+
+impl From<IdentString> for String {
+    fn from(v: IdentString) -> String {
+        v.string
+    }
+}
+
+impl Eq for IdentString {}
+
+impl PartialEq for IdentString {
+    fn eq(&self, rhs: &Self) -> bool {
+        self.ident == rhs.ident
+    }
+}
+
+impl PartialEq<String> for IdentString {
+    fn eq(&self, rhs: &String) -> bool {
+        self.as_str() == rhs
+    }
+}
+
+impl<'a> PartialEq<&'a str> for IdentString {
+    fn eq(&self, rhs: &&str) -> bool {
+        self.as_str() == *rhs
+    }
+}
+
+impl ToTokens for IdentString {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        self.ident.to_tokens(tokens);
+    }
+}
+
+impl fmt::Debug for IdentString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self.ident)
+    }
+}
+
+impl fmt::Display for IdentString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.ident)
+    }
+}
+
+impl FromMeta for IdentString {
+    fn from_meta(item: &Meta) -> Result<Self> {
+        Ident::from_meta(item).map(IdentString::from)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::IdentString;
+
+    #[test]
+    fn convert() {
+        let i_str = IdentString::new(parse_quote!(t));
+        assert_eq!(i_str.as_str(), "t");
+    }
+
+    #[test]
+    fn map_transform() {
+        let i = IdentString::new(parse_quote!(my));
+        let after = i.map(|v| format!("var_{}", v));
+        assert_eq!(after, "var_my");
+        assert_eq!(after, String::from("var_my"));
+    }
+}
--- a/third_party/rust/darling_core/src/util/ignored.rs
+++ b/third_party/rust/darling_core/src/util/ignored.rs
@@ -1,38 +1,52 @@
 use syn;
 
-use {FromMetaItem, FromDeriveInput, FromField, FromVariant, Result};
+use usage::{self, UsesLifetimes, UsesTypeParams};
+use {
+    FromDeriveInput, FromField, FromGenericParam, FromGenerics, FromMeta, FromTypeParam,
+    FromVariant, Result,
+};
 
-/// An efficient way of discarding data from an attribute.
+/// An efficient way of discarding data from a syntax element.
 ///
-/// All meta-items, fields, and variants will be successfully read into
+/// All syntax elements will be successfully read into
 /// the `Ignored` struct, with all properties discarded.
 #[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)
-    }
+macro_rules! ignored {
+    ($trayt:ident, $method:ident, $syn:path) => {
+        impl $trayt for Ignored {
+            fn $method(_: &$syn) -> Result<Self> {
+                Ok(Ignored)
+            }
+        }
+    };
+}
 
-    fn from_nested_meta_item(_: &syn::NestedMeta) -> Result<Self> {
-        Ok(Ignored)
+ignored!(FromGenericParam, from_generic_param, syn::GenericParam);
+ignored!(FromGenerics, from_generics, syn::Generics);
+ignored!(FromTypeParam, from_type_param, syn::TypeParam);
+ignored!(FromMeta, from_meta, syn::Meta);
+ignored!(FromDeriveInput, from_derive_input, syn::DeriveInput);
+ignored!(FromField, from_field, syn::Field);
+ignored!(FromVariant, from_variant, syn::Variant);
+
+impl UsesTypeParams for Ignored {
+    fn uses_type_params<'a>(
+        &self,
+        _opts: &usage::Options,
+        _: &'a usage::IdentSet,
+    ) -> usage::IdentRefSet<'a> {
+        Default::default()
     }
 }
 
-impl FromDeriveInput for Ignored {
-    fn from_derive_input(_: &syn::DeriveInput) -> Result<Self> {
-        Ok(Ignored)
+impl UsesLifetimes for Ignored {
+    fn uses_lifetimes<'a>(
+        &self,
+        _opts: &usage::Options,
+        _: &'a usage::LifetimeSet,
+    ) -> usage::LifetimeRefSet<'a> {
+        Default::default()
     }
 }
-
-impl FromField for Ignored {
-    fn from_field(_: &syn::Field) -> Result<Self> {
-        Ok(Ignored)
-    }
-}
-
-impl FromVariant for Ignored {
-    fn from_variant(_: &syn::Variant) -> Result<Self> {
-        Ok(Ignored)
-    }
-}
\ No newline at end of file
--- a/third_party/rust/darling_core/src/util/mod.rs
+++ b/third_party/rust/darling_core/src/util/mod.rs
@@ -1,22 +1,26 @@
 //! Utility types for attribute parsing.
 
-use std::ops::{Deref, Not, BitAnd, BitOr};
+use std::ops::{BitAnd, BitOr, Deref, Not};
 
 use syn;
-use {FromMetaItem, Result};
+use {FromMeta, Result};
 
 mod ident_list;
+mod ident_string;
 mod ignored;
 mod over_ride;
+mod with_original;
 
 pub use self::ident_list::IdentList;
+pub use self::ident_string::IdentString;
 pub use self::ignored::Ignored;
 pub use self::over_ride::Override;
+pub use self::with_original::WithOriginal;
 
 /// Marker type equivalent to `Option<()>` for use in attribute parsing.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct Flag(Option<()>);
 
 impl Flag {
     /// Creates a new `Flag` which corresponds to the presence of a value.
     pub fn present() -> Self {
@@ -26,31 +30,35 @@ impl Flag {
 
 impl Deref for Flag {
     type Target = Option<()>;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
-impl FromMetaItem for Flag {
-    fn from_meta_item(mi: &syn::Meta) -> Result<Self> {
-        FromMetaItem::from_meta_item(mi).map(Flag)
+impl FromMeta for Flag {
+    fn from_meta(mi: &syn::Meta) -> Result<Self> {
+        FromMeta::from_meta(mi).map(Flag)
     }
 }
 
 impl From<Flag> for bool {
     fn from(flag: Flag) -> Self {
         flag.is_some()
     }
 }
 
 impl From<bool> for Flag {
     fn from(v: bool) -> Self {
-        if v { Flag::present() } else { Flag(None) }
+        if v {
+            Flag::present()
+        } else {
+            Flag(None)
+        }
     }
 }
 
 impl From<Option<()>> for Flag {
     fn from(v: Option<()>) -> Self {
         Flag::from(v.is_some())
     }
 }
@@ -94,9 +102,9 @@ impl BitAnd for Flag {
 }
 
 impl BitOr for Flag {
     type Output = Self;
 
     fn bitor(self, rhs: Self) -> Self {
         (self.into() || rhs.into()).into()
     }
-}
\ No newline at end of file
+}
--- a/third_party/rust/darling_core/src/util/over_ride.rs
+++ b/third_party/rust/darling_core/src/util/over_ride.rs
@@ -1,13 +1,13 @@
 use std::fmt;
 
 use syn::{Lit, NestedMeta};
 
-use {Result, FromMetaItem};
+use {FromMeta, Result};
 
 use self::Override::*;
 
 /// A value which can inherit a default value or have an explicit value specified.
 ///
 /// # Usage
 /// This type is meant for attributes like `default` in `darling`, which can take the following forms:
 ///
@@ -37,66 +37,69 @@ use self::Override::*;
 /// The `word` format (with no associated value), would produce `Override::Inherit`, while a list
 /// or value format would produce `Override::Explicit`.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Override<T> {
     /// Inherit the eventual value from an external source.
     Inherit,
 
     /// Explicitly set the value.
-    Explicit(T)
+    Explicit(T),
 }
 
 impl<T> Override<T> {
     /// Converts from `Override<T>` to `Override<&T>`.
     ///
     /// Produces a new `Override`, containing a reference into the original, leaving the original in place.
     pub fn as_ref<'a>(&'a self) -> Override<&'a T> {
         match *self {
             Inherit => Inherit,
-            Explicit(ref val) => Explicit(val)
+            Explicit(ref val) => Explicit(val),
         }
     }
 
     /// Converts from `Override<T>` to `Override<&mut T>`.
     ///
     /// Produces a new `Override`, containing a mutable reference into the original.
     pub fn as_mut<'a>(&'a mut self) -> Override<&'a T> {
         match *self {
             Inherit => Inherit,
-            Explicit(ref mut val) => Explicit(val)
+            Explicit(ref mut val) => Explicit(val),
         }
     }
 
     /// Returns `true` if the override is an `Explicit` value.
     pub fn is_explicit(&self) -> bool {
         match *self {
             Inherit => false,
             Explicit(_) => true,
         }
     }
 
     /// Converts from `Override<T>` to `Option<T>`.
     pub fn explicit(self) -> Option<T> {
         match self {
             Inherit => None,
-            Explicit(val) => Some(val)
+            Explicit(val) => Some(val),
         }
     }
 
     /// Unwraps an override, yielding the content of an `Explicit`. Otherwise, it returns `optb`.
     pub fn unwrap_or(self, optb: T) -> T {
         match self {
             Inherit => optb,
             Explicit(val) => val,
         }
     }
 
     /// Unwraps an override, yielding the content of an `Explicit`. Otherwise, it calls `op`.
-    pub fn unwrap_or_else<F>(self, op: F) -> T where F: FnOnce() -> T {
+    pub fn unwrap_or_else<F>(self, op: F) -> T
+    where
+        F: FnOnce() -> T,
+    {
         match self {
             Inherit => op(),
             Explicit(val) => val,
         }
     }
 }
 
 impl<T: Default> Override<T> {
@@ -126,22 +129,22 @@ impl<T: fmt::Display> fmt::Display for O
         match *self {
             Inherit => write!(f, "Inherit"),
             Explicit(ref val) => write!(f, "Explicit `{}`", val),
         }
     }
 }
 
 /// Parses a `Meta`. A bare word will produce `Override::Inherit`, while
-/// any value will be forwarded to `T::from_meta_item`.
-impl<T: FromMetaItem> FromMetaItem for Override<T> {
+/// any value will be forwarded to `T::from_meta`.
+impl<T: FromMeta> FromMeta for Override<T> {
     fn from_word() -> Result<Self> {
         Ok(Inherit)
     }
 
     fn from_list(items: &[NestedMeta]) -> Result<Self> {
-        Ok(Explicit(FromMetaItem::from_list(items)?))
+        Ok(Explicit(FromMeta::from_list(items)?))
     }
 
     fn from_value(lit: &Lit) -> Result<Self> {
-        Ok(Explicit(FromMetaItem::from_value(lit)?))
+        Ok(Explicit(FromMeta::from_value(lit)?))
     }
-}
\ No newline at end of file
+}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/darling_core/src/util/with_original.rs
@@ -0,0 +1,35 @@
+use syn;
+
+use {FromDeriveInput, FromField, FromGenericParam, FromGenerics, FromMeta, FromTypeParam,
+     FromVariant, Result};
+
+/// A container to parse some syntax and retain access to the original.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct WithOriginal<T, O> {
+    pub parsed: T,
+    pub original: O,
+}
+
+impl<T, O> WithOriginal<T, O> {
+    pub fn new(parsed: T, original: O) -> Self {
+        WithOriginal { parsed, original }
+    }
+}
+
+macro_rules! with_original {
+    ($trayt:ident, $func:ident, $syn:path) => {
+        impl<T: $trayt> $trayt for WithOriginal<T, $syn> {
+            fn $func(value: &$syn) -> Result<Self> {
+                Ok(WithOriginal::new($trayt::$func(value)?, value.clone()))
+            }
+        }
+    };
+}
+
+with_original!(FromDeriveInput, from_derive_input, syn::DeriveInput);
+with_original!(FromField, from_field, syn::Field);
+with_original!(FromGenerics, from_generics, syn::Generics);
+with_original!(FromGenericParam, from_generic_param, syn::GenericParam);
+with_original!(FromMeta, from_meta, syn::Meta);
+with_original!(FromTypeParam, from_type_param, syn::TypeParam);
+with_original!(FromVariant, from_variant, syn::Variant);
--- 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":"cf9d579ee6af881a7aa52d43d637b4afa9cf589bfda3fa63159538d681855330","src/lib.rs":"d900da894985945215cb4494ebd4e8b5f697c19bf9e624a1bb03d22a0a5367a5"},"package":"eb69a38fdeaeaf3db712e1df170de67ee9dfc24fb88ca3e9d21e703ec25a4d8e"}
\ No newline at end of file
+{"files":{"Cargo.toml":"2603037629b2df2d1ce38ee7a163f745d4f08cd5a8c4c39efc828cd718445fbe","src/lib.rs":"8343bf4500faeaf72e0cafb9e2c378be176bfe41529ba8f0d5e315336de422bf"},"package":"9973050ba46be2a2935a7b316147f41a808ac604b8f0fef6eba77fd47a89daeb"}
\ 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.4.0"
+version = "0.8.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.4.0"
+version = "=0.8.0"
 
 [dependencies.quote]
-version = "0.5"
+version = "0.6"
 
 [dependencies.syn]
-version = "0.13"
+version = "0.15"
--- a/third_party/rust/darling_macro/src/lib.rs
+++ b/third_party/rust/darling_macro/src/lib.rs
@@ -1,53 +1,72 @@
 extern crate proc_macro;
 #[macro_use]
 extern crate quote;
+#[macro_use]
 extern crate syn;
 
 extern crate darling_core;
 
 use proc_macro::TokenStream;
 
-use darling_core::{options, codegen};
+use darling_core::{codegen, options};
 
-#[proc_macro_derive(FromMetaItem, attributes(darling))]
-pub fn derive_from_meta_item(input: TokenStream) -> TokenStream {
-    let ast: syn::DeriveInput = syn::parse(input).unwrap();
-    let container = options::FmiOptions::new(&ast).unwrap();
-    let trait_impl = codegen::FmiImpl::from(&container);
+#[proc_macro_derive(FromMeta, attributes(darling))]
+pub fn derive_from_meta(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as syn::DeriveInput);
+
+    let container = options::FromMetaOptions::new(&ast).unwrap();
+    let trait_impl = codegen::FromMetaImpl::from(&container);
     let result = quote!(#trait_impl);
 
     result.into()
 }
 
+#[proc_macro_derive(FromMetaItem, attributes(darling))]
+pub fn derive_from_meta_item(_input: TokenStream) -> TokenStream {
+    panic!("darling::FromMetaItem has been replaced by darling::FromMeta");
+}
+
+
 #[proc_macro_derive(FromDeriveInput, attributes(darling))]
 pub fn derive_from_input(input: TokenStream) -> TokenStream {
-    let ast: syn::DeriveInput = syn::parse(input).unwrap();
+    let ast = parse_macro_input!(input as syn::DeriveInput);
 
     let container = options::FdiOptions::new(&ast).unwrap();
     let trait_impl = codegen::FromDeriveInputImpl::from(&container);
     let result = quote!(#trait_impl);
 
     result.into()
 }
 
 #[proc_macro_derive(FromField, attributes(darling))]
 pub fn derive_field(input: TokenStream) -> TokenStream {
-    let ast: syn::DeriveInput = syn::parse(input).unwrap();
+    let ast = parse_macro_input!(input as syn::DeriveInput);
 
     let fdic = options::FromFieldOptions::new(&ast).unwrap();
     let trait_impl = codegen::FromFieldImpl::from(&fdic);
     let result = quote!(#trait_impl);
 
     result.into()
 }
 
+#[proc_macro_derive(FromTypeParam, attributes(darling))]
+pub fn derive_type_param(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as syn::DeriveInput);
+
+    let fdic = options::FromTypeParamOptions::new(&ast).unwrap();
+    let trait_impl = codegen::FromTypeParamImpl::from(&fdic);
+    let result = quote!(#trait_impl);
+
+    result.into()
+}
+
 #[proc_macro_derive(FromVariant, attributes(darling))]
 pub fn derive_variant(input: TokenStream) -> TokenStream {
-    let ast: syn::DeriveInput = syn::parse(input).unwrap();
+    let ast = parse_macro_input!(input as syn::DeriveInput);
 
     let fdic = options::FromVariantOptions::new(&ast).unwrap();
     let trait_impl = codegen::FromVariantImpl::from(&fdic);
     let result = quote!(#trait_impl);
 
     result.into()
 }
--- a/third_party/rust/fnv/.cargo-checksum.json
+++ b/third_party/rust/fnv/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{"Cargo.toml":"19864ecb948c0e7be14ead11068a2c689a4d31a684c85b6ad1bdf4a26d893516","README.md":"772c547b8e78764f07cc22f2294cb7c691cb20f30d459ed45a65c2434b1ca8a9","lib.rs":"2e2be31e9c90c9b2b0fe223f64f4b4bb24487e370e1cd2fbcce70d30f50fc452"},"package":"6cc484842f1e2884faf56f529f960cc12ad8c71ce96cc7abba0a067c98fee344"}
\ No newline at end of file
+{"files":{"Cargo.toml":"8a89e16dc6b373aa151fb2d1221c699b39b1dd5599aa616897fa85511b71104f","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"65fdb6c76cd61612070c066eec9ecdb30ee74fb27859d0d9af58b9f499fd0c3e","README.md":"9398b0785fdaf32fe61dca3d6f16e69cf53ab2911c9435053d1ec962cd92b8fa","lib.rs":"0303c8c75e9cf35f5379f67cfc003ba0b51e9643dc8f3bd346322595d7685d97"},"package":"2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"}
\ No newline at end of file
--- a/third_party/rust/fnv/Cargo.toml
+++ b/third_party/rust/fnv/Cargo.toml
@@ -1,13 +1,25 @@
+# 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 = "fnv"
-version = "1.0.5"
+version = "1.0.6"
 authors = ["Alex Crichton <alex@alexcrichton.com>"]
 description = "Fowler–Noll–Vo hash function"
-license = "Apache-2.0 / MIT"
+documentation = "https://doc.servo.org/fnv/"
 readme = "README.md"
+license = "Apache-2.0 / MIT"
 repository = "https://github.com/servo/rust-fnv"
-documentation = "https://doc.servo.org/fnv/"
 
 [lib]
 name = "fnv"
 path = "lib.rs"
new file mode 100644
--- /dev/null
+++ b/third_party/rust/fnv/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              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