Add structopt dependency in version 0.3.7

This patch series replaces argparse with structopt in the argument
handling code. As a first step, we need structopt as a dependency.

Import subrepo structopt/:structopt at efbdda4753592e27bc430fb01f7b9650b2f3174d
Import subrepo bitflags/:bitflags at 30668016aca6bd3b02c766e8347e0b4080d4c296
Import subrepo clap/:clap at 784524f7eb193e35f81082cc69454c8c21b948f7
Import subrepo heck/:heck at 093d56fbf001e1506e56dbfa38631d99b1066df1
Import subrepo proc-macro-error/:proc-macro-error at 6c4cfe79a622c5de8ae68557993542be46eacae2
Import subrepo proc-macro2/:proc-macro2 at d5d48eddca4566e5438e8a2cbed4a74e049544de
Import subrepo quote/:quote at 727436c6c137b20f0f34dde5d8fda2679b9747ad
Import subrepo rustversion/:rustversion at 0c5663313516263059ce9059ef81fc7a1cf655ca
Import subrepo syn-mid/:syn-mid at 5d3d85414a9e6674e1857ec22a87b96e04a6851a
Import subrepo syn/:syn at e87c27e87f6f4ef8919d0372bdb056d53ef0d8f3
Import subrepo textwrap/:textwrap at abcd618beae3f74841032aa5b53c1086b0a57ca2
Import subrepo unicode-segmentation/:unicode-segmentation at 637c9874c4fe0c205ff27787faf150a40295c6c3
Import subrepo unicode-width/:unicode-width at 3033826f8bf05e82724140a981d5941e48fce393
Import subrepo unicode-xid/:unicode-xid at 4baae9fffb156ba229665b972a9cd5991787ceb7

1 files changed, 193 insertions, 0 deletions

diff --git a/quote/benches/bench.rs b/quote/benches/bench.rs
new file mode 100644
index 0000000..c76a638
--- /dev/null
+++ b/quote/benches/bench.rs
@@ -0,0 +1,193 @@
+#![feature(test)]
+#![recursion_limit = "512"]
+
+extern crate test;
+
+use quote::quote;
+use test::Bencher;
+
+#[bench]
+fn bench_impl(b: &mut Bencher) {
+    b.iter(|| {
+        quote! {
+            impl<'de> _serde::Deserialize<'de> for Response {
+                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                where
+                    __D: _serde::Deserializer<'de>,
+                {
+                    #[allow(non_camel_case_types)]
+                    enum __Field {
+                        __field0,
+                        __field1,
+                        __ignore,
+                    }
+                    struct __FieldVisitor;
+                    impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
+                        type Value = __Field;
+                        fn expecting(
+                            &self,
+                            __formatter: &mut _serde::export::Formatter,
+                        ) -> _serde::export::fmt::Result {
+                            _serde::export::Formatter::write_str(__formatter, "field identifier")
+                        }
+                        fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                        where
+                            __E: _serde::de::Error,
+                        {
+                            match __value {
+                                0u64 => _serde::export::Ok(__Field::__field0),
+                                1u64 => _serde::export::Ok(__Field::__field1),
+                                _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"field index 0 <= i < 2",
+                                )),
+                            }
+                        }
+                        fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                        where
+                            __E: _serde::de::Error,
+                        {
+                            match __value {
+                                "id" => _serde::export::Ok(__Field::__field0),
+                                "s" => _serde::export::Ok(__Field::__field1),
+                                _ => _serde::export::Ok(__Field::__ignore),
+                            }
+                        }
+                        fn visit_bytes<__E>(
+                            self,
+                            __value: &[u8],
+                        ) -> _serde::export::Result<Self::Value, __E>
+                        where
+                            __E: _serde::de::Error,
+                        {
+                            match __value {
+                                b"id" => _serde::export::Ok(__Field::__field0),
+                                b"s" => _serde::export::Ok(__Field::__field1),
+                                _ => _serde::export::Ok(__Field::__ignore),
+                            }
+                        }
+                    }
+                    impl<'de> _serde::Deserialize<'de> for __Field {
+                        #[inline]
+                        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                        where
+                            __D: _serde::Deserializer<'de>,
+                        {
+                            _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                        }
+                    }
+                    struct __Visitor<'de> {
+                        marker: _serde::export::PhantomData<Response>,
+                        lifetime: _serde::export::PhantomData<&'de ()>,
+                    }
+                    impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
+                        type Value = Response;
+                        fn expecting(
+                            &self,
+                            __formatter: &mut _serde::export::Formatter,
+                        ) -> _serde::export::fmt::Result {
+                            _serde::export::Formatter::write_str(__formatter, "struct Response")
+                        }
+                        #[inline]
+                        fn visit_seq<__A>(
+                            self,
+                            mut __seq: __A,
+                        ) -> _serde::export::Result<Self::Value, __A::Error>
+                        where
+                            __A: _serde::de::SeqAccess<'de>,
+                        {
+                            let __field0 =
+                                match try!(_serde::de::SeqAccess::next_element::<u64>(&mut __seq)) {
+                                    _serde::export::Some(__value) => __value,
+                                    _serde::export::None => {
+                                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                                            0usize,
+                                            &"struct Response with 2 elements",
+                                        ));
+                                    }
+                                };
+                            let __field1 =
+                                match try!(_serde::de::SeqAccess::next_element::<String>(&mut __seq)) {
+                                    _serde::export::Some(__value) => __value,
+                                    _serde::export::None => {
+                                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                                            1usize,
+                                            &"struct Response with 2 elements",
+                                        ));
+                                    }
+                                };
+                            _serde::export::Ok(Response {
+                                id: __field0,
+                                s: __field1,
+                            })
+                        }
+                        #[inline]
+                        fn visit_map<__A>(
+                            self,
+                            mut __map: __A,
+                        ) -> _serde::export::Result<Self::Value, __A::Error>
+                        where
+                            __A: _serde::de::MapAccess<'de>,
+                        {
+                            let mut __field0: _serde::export::Option<u64> = _serde::export::None;
+                            let mut __field1: _serde::export::Option<String> = _serde::export::None;
+                            while let _serde::export::Some(__key) =
+                                try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map))
+                            {
+                                match __key {
+                                    __Field::__field0 => {
+                                        if _serde::export::Option::is_some(&__field0) {
+                                            return _serde::export::Err(
+                                                <__A::Error as _serde::de::Error>::duplicate_field("id"),
+                                            );
+                                        }
+                                        __field0 = _serde::export::Some(
+                                            try!(_serde::de::MapAccess::next_value::<u64>(&mut __map)),
+                                        );
+                                    }
+                                    __Field::__field1 => {
+                                        if _serde::export::Option::is_some(&__field1) {
+                                            return _serde::export::Err(
+                                                <__A::Error as _serde::de::Error>::duplicate_field("s"),
+                                            );
+                                        }
+                                        __field1 = _serde::export::Some(
+                                            try!(_serde::de::MapAccess::next_value::<String>(&mut __map)),
+                                        );
+                                    }
+                                    _ => {
+                                        let _ = try!(_serde::de::MapAccess::next_value::<
+                                            _serde::de::IgnoredAny,
+                                        >(&mut __map));
+                                    }
+                                }
+                            }
+                            let __field0 = match __field0 {
+                                _serde::export::Some(__field0) => __field0,
+                                _serde::export::None => try!(_serde::private::de::missing_field("id")),
+                            };
+                            let __field1 = match __field1 {
+                                _serde::export::Some(__field1) => __field1,
+                                _serde::export::None => try!(_serde::private::de::missing_field("s")),
+                            };
+                            _serde::export::Ok(Response {
+                                id: __field0,
+                                s: __field1,
+                            })
+                        }
+                    }
+                    const FIELDS: &'static [&'static str] = &["id", "s"];
+                    _serde::Deserializer::deserialize_struct(
+                        __deserializer,
+                        "Response",
+                        FIELDS,
+                        __Visitor {
+                            marker: _serde::export::PhantomData::<Response>,
+                            lifetime: _serde::export::PhantomData,
+                        },
+                    )
+                }
+            }
+        }
+    });
+}